fidl_fuchsia_virtualaudio__common/
fidl_fuchsia_virtualaudio__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const CONTROL_NODE_NAME: &str = "sys/platform/virtual-audio/virtual-audio";
12
13pub const LEGACY_CONTROL_NODE_NAME: &str = "sys/platform/virtual-audio-legacy/virtual-audio-legacy";
14
15pub const MAX_COUNT_DAI_INTERCONNECTS: u32 =
16    fidl_fuchsia_hardware_audio_signalprocessing__common::MAX_COUNT_PROCESSING_ELEMENTS as u32;
17
18pub const MAX_COUNT_RING_BUFFERS: u32 =
19    fidl_fuchsia_hardware_audio_signalprocessing__common::MAX_COUNT_PROCESSING_ELEMENTS as u32;
20
21pub const MAX_FORMAT_RANGES: u32 = 64;
22
23pub const MAX_UI_STRING_SIZE: u32 = 256;
24
25#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
26pub enum DeviceType {
27    /// Device supports the fuchsia.hardware.audio/StreamConfig protocol.
28    StreamConfig,
29    /// Device supports the fuchsia.hardware.audio/Dai protocol.
30    Dai,
31    /// Device supports the fuchsia.hardware.audio/Codec protocol.
32    Codec,
33    /// Device supports the fuchsia.hardware.audio/Composite protocol.
34    Composite,
35    #[doc(hidden)]
36    __SourceBreaking { unknown_ordinal: u32 },
37}
38
39/// Pattern that matches an unknown `DeviceType` member.
40#[macro_export]
41macro_rules! DeviceTypeUnknown {
42    () => {
43        _
44    };
45}
46
47impl DeviceType {
48    #[inline]
49    pub fn from_primitive(prim: u32) -> Option<Self> {
50        match prim {
51            1 => Some(Self::StreamConfig),
52            2 => Some(Self::Dai),
53            3 => Some(Self::Codec),
54            4 => Some(Self::Composite),
55            _ => None,
56        }
57    }
58
59    #[inline]
60    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
61        match prim {
62            1 => Self::StreamConfig,
63            2 => Self::Dai,
64            3 => Self::Codec,
65            4 => Self::Composite,
66            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
67        }
68    }
69
70    #[inline]
71    pub fn unknown() -> Self {
72        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
73    }
74
75    #[inline]
76    pub const fn into_primitive(self) -> u32 {
77        match self {
78            Self::StreamConfig => 1,
79            Self::Dai => 2,
80            Self::Codec => 3,
81            Self::Composite => 4,
82            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
83        }
84    }
85
86    #[inline]
87    pub fn is_unknown(&self) -> bool {
88        match self {
89            Self::__SourceBreaking { unknown_ordinal: _ } => true,
90            _ => false,
91        }
92    }
93}
94
95#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
96pub enum Error {
97    /// Unknown internal error occurred.
98    Internal,
99    /// The ring buffer has not been created yet.
100    NoRingBuffer,
101    /// The device has not yet started streaming.
102    NotStarted,
103    /// The operation is not implemented, supported, or enabled.
104    NotSupported,
105    /// An argument is invalid.
106    InvalidArgs,
107    #[doc(hidden)]
108    __SourceBreaking { unknown_ordinal: u32 },
109}
110
111/// Pattern that matches an unknown `Error` member.
112#[macro_export]
113macro_rules! ErrorUnknown {
114    () => {
115        _
116    };
117}
118
119impl Error {
120    #[inline]
121    pub fn from_primitive(prim: u32) -> Option<Self> {
122        match prim {
123            1 => Some(Self::Internal),
124            2 => Some(Self::NoRingBuffer),
125            3 => Some(Self::NotStarted),
126            4 => Some(Self::NotSupported),
127            5 => Some(Self::InvalidArgs),
128            _ => None,
129        }
130    }
131
132    #[inline]
133    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
134        match prim {
135            1 => Self::Internal,
136            2 => Self::NoRingBuffer,
137            3 => Self::NotStarted,
138            4 => Self::NotSupported,
139            5 => Self::InvalidArgs,
140            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
141        }
142    }
143
144    #[inline]
145    pub fn unknown() -> Self {
146        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
147    }
148
149    #[inline]
150    pub const fn into_primitive(self) -> u32 {
151        match self {
152            Self::Internal => 1,
153            Self::NoRingBuffer => 2,
154            Self::NotStarted => 3,
155            Self::NotSupported => 4,
156            Self::InvalidArgs => 5,
157            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
158        }
159    }
160
161    #[inline]
162    pub fn is_unknown(&self) -> bool {
163        match self {
164            Self::__SourceBreaking { unknown_ordinal: _ } => true,
165            _ => false,
166        }
167    }
168}
169
170#[derive(Clone, Debug, PartialEq)]
171pub struct ControlGetDefaultConfigurationRequest {
172    pub type_: DeviceType,
173    pub direction: Direction,
174}
175
176impl fidl::Persistable for ControlGetDefaultConfigurationRequest {}
177
178#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
179#[repr(C)]
180pub struct ControlGetNumDevicesResponse {
181    pub num_input_devices: u32,
182    pub num_output_devices: u32,
183    pub num_unspecified_direction_devices: u32,
184}
185
186impl fidl::Persistable for ControlGetNumDevicesResponse {}
187
188#[derive(Clone, Debug, PartialEq)]
189pub struct ControlGetDefaultConfigurationResponse {
190    pub config: Configuration,
191}
192
193impl fidl::Persistable for ControlGetDefaultConfigurationResponse {}
194
195#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
196#[repr(C)]
197pub struct DeviceAdjustClockRateRequest {
198    pub ppm_from_monotonic: i32,
199}
200
201impl fidl::Persistable for DeviceAdjustClockRateRequest {}
202
203#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
204pub struct DeviceChangePlugStateRequest {
205    pub plug_change_time: i64,
206    pub plugged: bool,
207}
208
209impl fidl::Persistable for DeviceChangePlugStateRequest {}
210
211#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
212#[repr(C)]
213pub struct DeviceOnPositionNotifyRequest {
214    pub monotonic_time: i64,
215    pub ring_position: u32,
216}
217
218impl fidl::Persistable for DeviceOnPositionNotifyRequest {}
219
220#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
221#[repr(C)]
222pub struct DeviceOnSetFormatRequest {
223    pub frames_per_second: u32,
224    pub sample_format: u32,
225    pub num_channels: u32,
226    pub external_delay: i64,
227}
228
229impl fidl::Persistable for DeviceOnSetFormatRequest {}
230
231#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
232pub struct DeviceOnSetGainRequest {
233    pub current_mute: bool,
234    pub current_agc: bool,
235    pub current_gain_db: f32,
236}
237
238impl fidl::Persistable for DeviceOnSetGainRequest {}
239
240#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
241#[repr(C)]
242pub struct DeviceOnStartRequest {
243    pub start_time: i64,
244}
245
246impl fidl::Persistable for DeviceOnStartRequest {}
247
248#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
249#[repr(C)]
250pub struct DeviceOnStopRequest {
251    pub stop_time: i64,
252    pub ring_position: u32,
253}
254
255impl fidl::Persistable for DeviceOnStopRequest {}
256
257#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
258#[repr(C)]
259pub struct DeviceSetNotificationFrequencyRequest {
260    pub notifications_per_ring: u32,
261}
262
263impl fidl::Persistable for DeviceSetNotificationFrequencyRequest {}
264
265#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
266#[repr(C)]
267pub struct DeviceGetFormatResponse {
268    pub frames_per_second: u32,
269    pub sample_format: u32,
270    pub num_channels: u32,
271    pub external_delay: i64,
272}
273
274impl fidl::Persistable for DeviceGetFormatResponse {}
275
276#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
277pub struct DeviceGetGainResponse {
278    pub current_mute: bool,
279    pub current_agc: bool,
280    pub current_gain_db: f32,
281}
282
283impl fidl::Persistable for DeviceGetGainResponse {}
284
285#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
286#[repr(C)]
287pub struct DeviceGetPositionResponse {
288    pub monotonic_time: i64,
289    pub ring_position: u32,
290}
291
292impl fidl::Persistable for DeviceGetPositionResponse {}
293
294#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
295#[repr(C)]
296pub struct FormatRange {
297    /// Has type audio_sample_format_t (see zircon/device/audio.h)
298    pub sample_format_flags: u32,
299    pub min_frame_rate: u32,
300    pub max_frame_rate: u32,
301    pub min_channels: u8,
302    pub max_channels: u8,
303    /// Bitfield of `ASF_RANGE_FLAG_FPS_*` flags (see zircon/device/audio.h)
304    pub rate_family_flags: u16,
305}
306
307impl fidl::Persistable for FormatRange {}
308
309/// Set restrictions for the device ring buffer. This must be called before
310/// calling `Add()`, or after `Remove()`. Once the device is activated, the
311/// ring buffer and its size are returned by the driver in response to an
312/// `AUDIO_RB_CMD_GET_BUFFER` command on the ring buffer channel.
313/// Note: both min_frames and max_frames must be multiples of modulo_frames.
314#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
315#[repr(C)]
316pub struct RingBufferConstraints {
317    /// The ring buffer must have at least this many frames.
318    /// Must be a multiple of `modulo_frames`.
319    pub min_frames: u32,
320    /// The ring buffer can have at most this many frames.
321    /// Must be a multiple of `modulo_frames`.
322    pub max_frames: u32,
323    /// The ring buffer must have a multiple of this many frames.
324    /// Cannot be zero.
325    pub modulo_frames: u32,
326}
327
328impl fidl::Persistable for RingBufferConstraints {}
329
330#[derive(Clone, Debug, Default, PartialEq)]
331pub struct ClockProperties {
332    /// The clock domain is an int32 provided by the clock tree to an audio
333    /// driver. special values for `CLOCK_DOMAIN_MONOTONIC` (0), and
334    /// `CLOCK_DOMAIN_EXTERNAL` (-1) (not locally controllable) are defined in
335    /// `fuchsia.hardware.audio`. Note: other than -1, clients should treat any
336    /// negative `clock_domain` value as invalid.
337    ///
338    /// Optional.
339    pub domain: Option<i32>,
340    /// Rate-adjustment value for this clock. If omitted, treated as 0 ppm.
341    ///
342    /// Optional.
343    pub rate_adjustment_ppm: Option<i32>,
344    #[doc(hidden)]
345    pub __source_breaking: fidl::marker::SourceBreaking,
346}
347
348impl fidl::Persistable for ClockProperties {}
349
350/// Configuration for a fuchsia.hardware.audio/Codec driver.
351#[derive(Clone, Debug, Default, PartialEq)]
352pub struct Codec {
353    /// Device type is input (true) or output (false).
354    /// If unspecified, then the driver may be used for both input and output.
355    ///
356    /// Optional.
357    pub is_input: Option<bool>,
358    /// Configuration for the device's DAI interconnect.
359    ///
360    /// Required.
361    pub dai_interconnect: Option<DaiInterconnect>,
362    /// Configuration of the device's plug state.
363    ///
364    /// Required.
365    pub plug_properties: Option<PlugProperties>,
366    #[doc(hidden)]
367    pub __source_breaking: fidl::marker::SourceBreaking,
368}
369
370impl fidl::Persistable for Codec {}
371
372/// Configuration for a fuchsia.hardware.audio/Composite driver.
373#[derive(Clone, Debug, Default, PartialEq)]
374pub struct Composite {
375    /// Ring buffers configuration.
376    ///
377    /// Required.
378    pub ring_buffers: Option<Vec<CompositeRingBuffer>>,
379    /// DAI interconnects configurations.
380    ///
381    /// Required.
382    pub dai_interconnects: Option<Vec<CompositeDaiInterconnect>>,
383    /// Configuration for the device's clock.
384    ///
385    /// Required.
386    pub clock_properties: Option<ClockProperties>,
387    /// Topologies supported via the signalprocessing API.
388    ///
389    /// Optional.
390    pub topologies: Option<Vec<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology>>,
391    #[doc(hidden)]
392    pub __source_breaking: fidl::marker::SourceBreaking,
393}
394
395impl fidl::Persistable for Composite {}
396
397/// Configuration for a DAI interconnect as used by a Composite driver.
398#[derive(Clone, Debug, Default, PartialEq)]
399pub struct CompositeDaiInterconnect {
400    /// Signal processing id for this composite device DAI interconnect.
401    ///
402    /// Required.
403    pub id: Option<u64>,
404    /// Configuration for this DAI interconnect.
405    ///
406    /// Required.
407    pub dai_interconnect: Option<DaiInterconnect>,
408    #[doc(hidden)]
409    pub __source_breaking: fidl::marker::SourceBreaking,
410}
411
412impl fidl::Persistable for CompositeDaiInterconnect {}
413
414/// Configuration for a fuchsia.hardware.audio/RingBuffer as used by a Composite driver.
415#[derive(Clone, Debug, Default, PartialEq)]
416pub struct CompositeRingBuffer {
417    /// Signal processing id for this composite device ring buffer.
418    ///
419    /// Required.
420    pub id: Option<u64>,
421    /// Configuration for this ring buffer.
422    ///
423    /// Required.
424    pub ring_buffer: Option<RingBuffer>,
425    #[doc(hidden)]
426    pub __source_breaking: fidl::marker::SourceBreaking,
427}
428
429impl fidl::Persistable for CompositeRingBuffer {}
430
431/// Configures a virtual audio device.
432#[derive(Clone, Debug, Default, PartialEq)]
433pub struct Configuration {
434    /// Device's name.
435    ///
436    /// Optional.
437    pub device_name: Option<String>,
438    /// Device manufacturer's name.
439    ///
440    /// Optional.
441    pub manufacturer_name: Option<String>,
442    /// Device's product name.
443    ///
444    /// Optional.
445    pub product_name: Option<String>,
446    /// Device's unique identifier, a 16 byte string.
447    /// This field is only valid for `device_type` `STREAM_CONFIG` and `CODEC`.
448    /// If it is specified for another device_type, the AddDevice call will
449    /// fail with `INVALID_ARGS`.
450    ///
451    /// Optional.
452    pub unique_id: Option<[u8; 16]>,
453    /// The configuration specific to this device type.
454    /// The device type is determined by which `DeviceSpecific` union
455    /// member is defined.
456    ///
457    /// Required.
458    pub device_specific: Option<DeviceSpecific>,
459    #[doc(hidden)]
460    pub __source_breaking: fidl::marker::SourceBreaking,
461}
462
463impl fidl::Persistable for Configuration {}
464
465/// Configuration for a fuchsia.hardware.audio/Dai driver.
466#[derive(Clone, Debug, Default, PartialEq)]
467pub struct Dai {
468    /// Device type is input (true) or output (false).
469    ///
470    /// Optional.
471    pub is_input: Option<bool>,
472    /// Configuration for the device ring buffer.
473    ///
474    /// Required.
475    pub ring_buffer: Option<RingBuffer>,
476    /// Configuration for the device DAI interconnect.
477    ///
478    /// Required.
479    pub dai_interconnect: Option<DaiInterconnect>,
480    /// Configuration for the device's clock.
481    ///
482    /// Required.
483    pub clock_properties: Option<ClockProperties>,
484    #[doc(hidden)]
485    pub __source_breaking: fidl::marker::SourceBreaking,
486}
487
488impl fidl::Persistable for Dai {}
489
490/// Configuration for a DAI interconnect.
491#[derive(Clone, Debug, Default, PartialEq)]
492pub struct DaiInterconnect {
493    /// DAI interconnect supported formats.
494    ///
495    /// Required.
496    pub dai_supported_formats:
497        Option<Vec<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats>>,
498    #[doc(hidden)]
499    pub __source_breaking: fidl::marker::SourceBreaking,
500}
501
502impl fidl::Persistable for DaiInterconnect {}
503
504#[derive(Clone, Debug, Default, PartialEq)]
505pub struct Direction {
506    /// Device type is input (true) or output (false)
507    /// If unspecified, then the driver may be used for both input and output.
508    ///
509    /// For StreamConfig devices `is_input` is required.
510    /// For Dai devices `is_input` is required.
511    /// For Codec devices `is_input` is optional.
512    /// For Composite devices `is_input` is ignored.
513    ///
514    /// Optional.
515    pub is_input: Option<bool>,
516    #[doc(hidden)]
517    pub __source_breaking: fidl::marker::SourceBreaking,
518}
519
520impl fidl::Persistable for Direction {}
521
522#[derive(Clone, Debug, Default, PartialEq)]
523pub struct GainProperties {
524    /// The initial gain state at device initialization time.
525    ///
526    /// Required.
527    pub gain_state: Option<fidl_fuchsia_hardware_audio__common::GainState>,
528    /// The device's minimum gain, in decibels.
529    ///
530    /// Optional.
531    pub min_gain_db: Option<f32>,
532    /// The device's maximum gain, in decibels.
533    ///
534    /// Optional.
535    pub max_gain_db: Option<f32>,
536    /// The precision of each gain-change step, in decibels.
537    ///
538    /// Optional.
539    pub gain_step_db: Option<f32>,
540    /// If true, the device contains a distinct MUTE control. If false or
541    /// absent, it does not.
542    ///
543    /// Optional.
544    pub can_mute: Option<bool>,
545    /// Automatic Gain Control. If absent, this hardware does not support AGC.
546    ///
547    /// Optional.
548    pub can_agc: Option<bool>,
549    #[doc(hidden)]
550    pub __source_breaking: fidl::marker::SourceBreaking,
551}
552
553impl fidl::Persistable for GainProperties {}
554
555#[derive(Clone, Debug, Default, PartialEq)]
556pub struct PlugProperties {
557    /// The initial plug state at device initialization time.
558    ///
559    /// Required.
560    pub plug_state: Option<fidl_fuchsia_hardware_audio__common::PlugState>,
561    /// Plug Detect Capabilities.
562    ///
563    /// Optional.
564    pub plug_detect_capabilities:
565        Option<fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities>,
566    #[doc(hidden)]
567    pub __source_breaking: fidl::marker::SourceBreaking,
568}
569
570impl fidl::Persistable for PlugProperties {}
571
572/// Configuration for a fuchsia.hardware.audio/RingBuffer.
573#[derive(Clone, Debug, Default, PartialEq)]
574pub struct RingBuffer {
575    /// Driver transfer bytes.
576    ///
577    /// Optional.
578    pub driver_transfer_bytes: Option<u32>,
579    /// Internal delay.
580    ///
581    /// Optional.
582    pub internal_delay: Option<i64>,
583    /// External delay.
584    ///
585    /// Optional.
586    pub external_delay: Option<i64>,
587    /// Supported ring buffer format ranges for this ring buffer.
588    ///
589    /// Required.
590    pub supported_formats: Option<Vec<FormatRange>>,
591    /// Constraints on the ring buffer.
592    /// If unspecified, there are no constraints.
593    ///
594    /// Optional.
595    pub ring_buffer_constraints: Option<RingBufferConstraints>,
596    /// Notification frequency.
597    /// This can be changed later with SetNotificationFrequency.
598    /// If unspecified, the notification frequency will be the same as that
599    /// specified by the client when retrieving the RingBuffer VMO.
600    ///
601    /// Optional.
602    pub notifications_per_ring: Option<u32>,
603    #[doc(hidden)]
604    pub __source_breaking: fidl::marker::SourceBreaking,
605}
606
607impl fidl::Persistable for RingBuffer {}
608
609/// Configuration for a fuchsia.hardware.audio/StreamConfig driver.
610#[derive(Clone, Debug, Default, PartialEq)]
611pub struct StreamConfig {
612    /// Device type is input (true) or output (false).
613    /// This is required such that a user can find a device in devfs in either
614    /// the `/dev/class/audio-output' or `/dev/class/audio-input`, otherwise it
615    /// would be optional such that a driver could be misconfigured on purpose to
616    /// not have an `is_input` field.
617    ///
618    /// Required.
619    pub is_input: Option<bool>,
620    /// Configuration for the device ring buffer.
621    ///
622    /// Required.
623    pub ring_buffer: Option<RingBuffer>,
624    /// Configuration for the device's clock.
625    ///
626    /// Required.
627    pub clock_properties: Option<ClockProperties>,
628    /// Configuration of the device gain.
629    ///
630    /// Required.
631    pub gain_properties: Option<GainProperties>,
632    /// Configuration of the device's plug state.
633    ///
634    /// Required.
635    pub plug_properties: Option<PlugProperties>,
636    #[doc(hidden)]
637    pub __source_breaking: fidl::marker::SourceBreaking,
638}
639
640impl fidl::Persistable for StreamConfig {}
641
642/// Configuration for various types of drivers.
643#[derive(Clone, Debug)]
644pub enum DeviceSpecific {
645    /// Configuration for a fuchsia.hardware.audio/StreamConfig driver.
646    StreamConfig(StreamConfig),
647    /// Configuration for a fuchsia.hardware.audio/Dai driver.
648    Dai(Dai),
649    /// Configuration for a fuchsia.hardware.audio/Codec driver.
650    Codec(Codec),
651    /// Configuration for a fuchsia.hardware.audio/Composite driver.
652    Composite(Composite),
653    #[doc(hidden)]
654    __SourceBreaking { unknown_ordinal: u64 },
655}
656
657/// Pattern that matches an unknown `DeviceSpecific` member.
658#[macro_export]
659macro_rules! DeviceSpecificUnknown {
660    () => {
661        _
662    };
663}
664
665// Custom PartialEq so that unknown variants are not equal to themselves.
666impl PartialEq for DeviceSpecific {
667    fn eq(&self, other: &Self) -> bool {
668        match (self, other) {
669            (Self::StreamConfig(x), Self::StreamConfig(y)) => *x == *y,
670            (Self::Dai(x), Self::Dai(y)) => *x == *y,
671            (Self::Codec(x), Self::Codec(y)) => *x == *y,
672            (Self::Composite(x), Self::Composite(y)) => *x == *y,
673            _ => false,
674        }
675    }
676}
677
678impl DeviceSpecific {
679    #[inline]
680    pub fn ordinal(&self) -> u64 {
681        match *self {
682            Self::StreamConfig(_) => 1,
683            Self::Dai(_) => 2,
684            Self::Codec(_) => 3,
685            Self::Composite(_) => 4,
686            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
687        }
688    }
689
690    #[inline]
691    pub fn unknown_variant_for_testing() -> Self {
692        Self::__SourceBreaking { unknown_ordinal: 0 }
693    }
694
695    #[inline]
696    pub fn is_unknown(&self) -> bool {
697        match self {
698            Self::__SourceBreaking { .. } => true,
699            _ => false,
700        }
701    }
702}
703
704impl fidl::Persistable for DeviceSpecific {}
705
706mod internal {
707    use super::*;
708    unsafe impl fidl::encoding::TypeMarker for DeviceType {
709        type Owned = Self;
710
711        #[inline(always)]
712        fn inline_align(_context: fidl::encoding::Context) -> usize {
713            std::mem::align_of::<u32>()
714        }
715
716        #[inline(always)]
717        fn inline_size(_context: fidl::encoding::Context) -> usize {
718            std::mem::size_of::<u32>()
719        }
720
721        #[inline(always)]
722        fn encode_is_copy() -> bool {
723            false
724        }
725
726        #[inline(always)]
727        fn decode_is_copy() -> bool {
728            false
729        }
730    }
731
732    impl fidl::encoding::ValueTypeMarker for DeviceType {
733        type Borrowed<'a> = Self;
734        #[inline(always)]
735        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
736            *value
737        }
738    }
739
740    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
741        #[inline]
742        unsafe fn encode(
743            self,
744            encoder: &mut fidl::encoding::Encoder<'_, D>,
745            offset: usize,
746            _depth: fidl::encoding::Depth,
747        ) -> fidl::Result<()> {
748            encoder.debug_check_bounds::<Self>(offset);
749            encoder.write_num(self.into_primitive(), offset);
750            Ok(())
751        }
752    }
753
754    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
755        #[inline(always)]
756        fn new_empty() -> Self {
757            Self::unknown()
758        }
759
760        #[inline]
761        unsafe fn decode(
762            &mut self,
763            decoder: &mut fidl::encoding::Decoder<'_, D>,
764            offset: usize,
765            _depth: fidl::encoding::Depth,
766        ) -> fidl::Result<()> {
767            decoder.debug_check_bounds::<Self>(offset);
768            let prim = decoder.read_num::<u32>(offset);
769
770            *self = Self::from_primitive_allow_unknown(prim);
771            Ok(())
772        }
773    }
774    unsafe impl fidl::encoding::TypeMarker for Error {
775        type Owned = Self;
776
777        #[inline(always)]
778        fn inline_align(_context: fidl::encoding::Context) -> usize {
779            std::mem::align_of::<u32>()
780        }
781
782        #[inline(always)]
783        fn inline_size(_context: fidl::encoding::Context) -> usize {
784            std::mem::size_of::<u32>()
785        }
786
787        #[inline(always)]
788        fn encode_is_copy() -> bool {
789            false
790        }
791
792        #[inline(always)]
793        fn decode_is_copy() -> bool {
794            false
795        }
796    }
797
798    impl fidl::encoding::ValueTypeMarker for Error {
799        type Borrowed<'a> = Self;
800        #[inline(always)]
801        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
802            *value
803        }
804    }
805
806    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
807        #[inline]
808        unsafe fn encode(
809            self,
810            encoder: &mut fidl::encoding::Encoder<'_, D>,
811            offset: usize,
812            _depth: fidl::encoding::Depth,
813        ) -> fidl::Result<()> {
814            encoder.debug_check_bounds::<Self>(offset);
815            encoder.write_num(self.into_primitive(), offset);
816            Ok(())
817        }
818    }
819
820    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
821        #[inline(always)]
822        fn new_empty() -> Self {
823            Self::unknown()
824        }
825
826        #[inline]
827        unsafe fn decode(
828            &mut self,
829            decoder: &mut fidl::encoding::Decoder<'_, D>,
830            offset: usize,
831            _depth: fidl::encoding::Depth,
832        ) -> fidl::Result<()> {
833            decoder.debug_check_bounds::<Self>(offset);
834            let prim = decoder.read_num::<u32>(offset);
835
836            *self = Self::from_primitive_allow_unknown(prim);
837            Ok(())
838        }
839    }
840
841    impl fidl::encoding::ValueTypeMarker for ControlGetDefaultConfigurationRequest {
842        type Borrowed<'a> = &'a Self;
843        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
844            value
845        }
846    }
847
848    unsafe impl fidl::encoding::TypeMarker for ControlGetDefaultConfigurationRequest {
849        type Owned = Self;
850
851        #[inline(always)]
852        fn inline_align(_context: fidl::encoding::Context) -> usize {
853            8
854        }
855
856        #[inline(always)]
857        fn inline_size(_context: fidl::encoding::Context) -> usize {
858            24
859        }
860    }
861
862    unsafe impl<D: fidl::encoding::ResourceDialect>
863        fidl::encoding::Encode<ControlGetDefaultConfigurationRequest, D>
864        for &ControlGetDefaultConfigurationRequest
865    {
866        #[inline]
867        unsafe fn encode(
868            self,
869            encoder: &mut fidl::encoding::Encoder<'_, D>,
870            offset: usize,
871            _depth: fidl::encoding::Depth,
872        ) -> fidl::Result<()> {
873            encoder.debug_check_bounds::<ControlGetDefaultConfigurationRequest>(offset);
874            // Delegate to tuple encoding.
875            fidl::encoding::Encode::<ControlGetDefaultConfigurationRequest, D>::encode(
876                (
877                    <DeviceType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
878                    <Direction as fidl::encoding::ValueTypeMarker>::borrow(&self.direction),
879                ),
880                encoder,
881                offset,
882                _depth,
883            )
884        }
885    }
886    unsafe impl<
887            D: fidl::encoding::ResourceDialect,
888            T0: fidl::encoding::Encode<DeviceType, D>,
889            T1: fidl::encoding::Encode<Direction, D>,
890        > fidl::encoding::Encode<ControlGetDefaultConfigurationRequest, D> for (T0, T1)
891    {
892        #[inline]
893        unsafe fn encode(
894            self,
895            encoder: &mut fidl::encoding::Encoder<'_, D>,
896            offset: usize,
897            depth: fidl::encoding::Depth,
898        ) -> fidl::Result<()> {
899            encoder.debug_check_bounds::<ControlGetDefaultConfigurationRequest>(offset);
900            // Zero out padding regions. There's no need to apply masks
901            // because the unmasked parts will be overwritten by fields.
902            unsafe {
903                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
904                (ptr as *mut u64).write_unaligned(0);
905            }
906            // Write the fields.
907            self.0.encode(encoder, offset + 0, depth)?;
908            self.1.encode(encoder, offset + 8, depth)?;
909            Ok(())
910        }
911    }
912
913    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
914        for ControlGetDefaultConfigurationRequest
915    {
916        #[inline(always)]
917        fn new_empty() -> Self {
918            Self {
919                type_: fidl::new_empty!(DeviceType, D),
920                direction: fidl::new_empty!(Direction, D),
921            }
922        }
923
924        #[inline]
925        unsafe fn decode(
926            &mut self,
927            decoder: &mut fidl::encoding::Decoder<'_, D>,
928            offset: usize,
929            _depth: fidl::encoding::Depth,
930        ) -> fidl::Result<()> {
931            decoder.debug_check_bounds::<Self>(offset);
932            // Verify that padding bytes are zero.
933            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
934            let padval = unsafe { (ptr as *const u64).read_unaligned() };
935            let mask = 0xffffffff00000000u64;
936            let maskedval = padval & mask;
937            if maskedval != 0 {
938                return Err(fidl::Error::NonZeroPadding {
939                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
940                });
941            }
942            fidl::decode!(DeviceType, D, &mut self.type_, decoder, offset + 0, _depth)?;
943            fidl::decode!(Direction, D, &mut self.direction, decoder, offset + 8, _depth)?;
944            Ok(())
945        }
946    }
947
948    impl fidl::encoding::ValueTypeMarker for ControlGetNumDevicesResponse {
949        type Borrowed<'a> = &'a Self;
950        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
951            value
952        }
953    }
954
955    unsafe impl fidl::encoding::TypeMarker for ControlGetNumDevicesResponse {
956        type Owned = Self;
957
958        #[inline(always)]
959        fn inline_align(_context: fidl::encoding::Context) -> usize {
960            4
961        }
962
963        #[inline(always)]
964        fn inline_size(_context: fidl::encoding::Context) -> usize {
965            12
966        }
967        #[inline(always)]
968        fn encode_is_copy() -> bool {
969            true
970        }
971
972        #[inline(always)]
973        fn decode_is_copy() -> bool {
974            true
975        }
976    }
977
978    unsafe impl<D: fidl::encoding::ResourceDialect>
979        fidl::encoding::Encode<ControlGetNumDevicesResponse, D> for &ControlGetNumDevicesResponse
980    {
981        #[inline]
982        unsafe fn encode(
983            self,
984            encoder: &mut fidl::encoding::Encoder<'_, D>,
985            offset: usize,
986            _depth: fidl::encoding::Depth,
987        ) -> fidl::Result<()> {
988            encoder.debug_check_bounds::<ControlGetNumDevicesResponse>(offset);
989            unsafe {
990                // Copy the object into the buffer.
991                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
992                (buf_ptr as *mut ControlGetNumDevicesResponse)
993                    .write_unaligned((self as *const ControlGetNumDevicesResponse).read());
994                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
995                // done second because the memcpy will write garbage to these bytes.
996            }
997            Ok(())
998        }
999    }
1000    unsafe impl<
1001            D: fidl::encoding::ResourceDialect,
1002            T0: fidl::encoding::Encode<u32, D>,
1003            T1: fidl::encoding::Encode<u32, D>,
1004            T2: fidl::encoding::Encode<u32, D>,
1005        > fidl::encoding::Encode<ControlGetNumDevicesResponse, D> for (T0, T1, T2)
1006    {
1007        #[inline]
1008        unsafe fn encode(
1009            self,
1010            encoder: &mut fidl::encoding::Encoder<'_, D>,
1011            offset: usize,
1012            depth: fidl::encoding::Depth,
1013        ) -> fidl::Result<()> {
1014            encoder.debug_check_bounds::<ControlGetNumDevicesResponse>(offset);
1015            // Zero out padding regions. There's no need to apply masks
1016            // because the unmasked parts will be overwritten by fields.
1017            // Write the fields.
1018            self.0.encode(encoder, offset + 0, depth)?;
1019            self.1.encode(encoder, offset + 4, depth)?;
1020            self.2.encode(encoder, offset + 8, depth)?;
1021            Ok(())
1022        }
1023    }
1024
1025    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1026        for ControlGetNumDevicesResponse
1027    {
1028        #[inline(always)]
1029        fn new_empty() -> Self {
1030            Self {
1031                num_input_devices: fidl::new_empty!(u32, D),
1032                num_output_devices: fidl::new_empty!(u32, D),
1033                num_unspecified_direction_devices: fidl::new_empty!(u32, D),
1034            }
1035        }
1036
1037        #[inline]
1038        unsafe fn decode(
1039            &mut self,
1040            decoder: &mut fidl::encoding::Decoder<'_, D>,
1041            offset: usize,
1042            _depth: fidl::encoding::Depth,
1043        ) -> fidl::Result<()> {
1044            decoder.debug_check_bounds::<Self>(offset);
1045            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1046            // Verify that padding bytes are zero.
1047            // Copy from the buffer into the object.
1048            unsafe {
1049                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
1050            }
1051            Ok(())
1052        }
1053    }
1054
1055    impl fidl::encoding::ValueTypeMarker for ControlGetDefaultConfigurationResponse {
1056        type Borrowed<'a> = &'a Self;
1057        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1058            value
1059        }
1060    }
1061
1062    unsafe impl fidl::encoding::TypeMarker for ControlGetDefaultConfigurationResponse {
1063        type Owned = Self;
1064
1065        #[inline(always)]
1066        fn inline_align(_context: fidl::encoding::Context) -> usize {
1067            8
1068        }
1069
1070        #[inline(always)]
1071        fn inline_size(_context: fidl::encoding::Context) -> usize {
1072            16
1073        }
1074    }
1075
1076    unsafe impl<D: fidl::encoding::ResourceDialect>
1077        fidl::encoding::Encode<ControlGetDefaultConfigurationResponse, D>
1078        for &ControlGetDefaultConfigurationResponse
1079    {
1080        #[inline]
1081        unsafe fn encode(
1082            self,
1083            encoder: &mut fidl::encoding::Encoder<'_, D>,
1084            offset: usize,
1085            _depth: fidl::encoding::Depth,
1086        ) -> fidl::Result<()> {
1087            encoder.debug_check_bounds::<ControlGetDefaultConfigurationResponse>(offset);
1088            // Delegate to tuple encoding.
1089            fidl::encoding::Encode::<ControlGetDefaultConfigurationResponse, D>::encode(
1090                (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
1091                encoder,
1092                offset,
1093                _depth,
1094            )
1095        }
1096    }
1097    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
1098        fidl::encoding::Encode<ControlGetDefaultConfigurationResponse, D> for (T0,)
1099    {
1100        #[inline]
1101        unsafe fn encode(
1102            self,
1103            encoder: &mut fidl::encoding::Encoder<'_, D>,
1104            offset: usize,
1105            depth: fidl::encoding::Depth,
1106        ) -> fidl::Result<()> {
1107            encoder.debug_check_bounds::<ControlGetDefaultConfigurationResponse>(offset);
1108            // Zero out padding regions. There's no need to apply masks
1109            // because the unmasked parts will be overwritten by fields.
1110            // Write the fields.
1111            self.0.encode(encoder, offset + 0, depth)?;
1112            Ok(())
1113        }
1114    }
1115
1116    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1117        for ControlGetDefaultConfigurationResponse
1118    {
1119        #[inline(always)]
1120        fn new_empty() -> Self {
1121            Self { config: fidl::new_empty!(Configuration, D) }
1122        }
1123
1124        #[inline]
1125        unsafe fn decode(
1126            &mut self,
1127            decoder: &mut fidl::encoding::Decoder<'_, D>,
1128            offset: usize,
1129            _depth: fidl::encoding::Depth,
1130        ) -> fidl::Result<()> {
1131            decoder.debug_check_bounds::<Self>(offset);
1132            // Verify that padding bytes are zero.
1133            fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
1134            Ok(())
1135        }
1136    }
1137
1138    impl fidl::encoding::ValueTypeMarker for DeviceAdjustClockRateRequest {
1139        type Borrowed<'a> = &'a Self;
1140        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1141            value
1142        }
1143    }
1144
1145    unsafe impl fidl::encoding::TypeMarker for DeviceAdjustClockRateRequest {
1146        type Owned = Self;
1147
1148        #[inline(always)]
1149        fn inline_align(_context: fidl::encoding::Context) -> usize {
1150            4
1151        }
1152
1153        #[inline(always)]
1154        fn inline_size(_context: fidl::encoding::Context) -> usize {
1155            4
1156        }
1157        #[inline(always)]
1158        fn encode_is_copy() -> bool {
1159            true
1160        }
1161
1162        #[inline(always)]
1163        fn decode_is_copy() -> bool {
1164            true
1165        }
1166    }
1167
1168    unsafe impl<D: fidl::encoding::ResourceDialect>
1169        fidl::encoding::Encode<DeviceAdjustClockRateRequest, D> for &DeviceAdjustClockRateRequest
1170    {
1171        #[inline]
1172        unsafe fn encode(
1173            self,
1174            encoder: &mut fidl::encoding::Encoder<'_, D>,
1175            offset: usize,
1176            _depth: fidl::encoding::Depth,
1177        ) -> fidl::Result<()> {
1178            encoder.debug_check_bounds::<DeviceAdjustClockRateRequest>(offset);
1179            unsafe {
1180                // Copy the object into the buffer.
1181                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1182                (buf_ptr as *mut DeviceAdjustClockRateRequest)
1183                    .write_unaligned((self as *const DeviceAdjustClockRateRequest).read());
1184                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1185                // done second because the memcpy will write garbage to these bytes.
1186            }
1187            Ok(())
1188        }
1189    }
1190    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1191        fidl::encoding::Encode<DeviceAdjustClockRateRequest, D> for (T0,)
1192    {
1193        #[inline]
1194        unsafe fn encode(
1195            self,
1196            encoder: &mut fidl::encoding::Encoder<'_, D>,
1197            offset: usize,
1198            depth: fidl::encoding::Depth,
1199        ) -> fidl::Result<()> {
1200            encoder.debug_check_bounds::<DeviceAdjustClockRateRequest>(offset);
1201            // Zero out padding regions. There's no need to apply masks
1202            // because the unmasked parts will be overwritten by fields.
1203            // Write the fields.
1204            self.0.encode(encoder, offset + 0, depth)?;
1205            Ok(())
1206        }
1207    }
1208
1209    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1210        for DeviceAdjustClockRateRequest
1211    {
1212        #[inline(always)]
1213        fn new_empty() -> Self {
1214            Self { ppm_from_monotonic: fidl::new_empty!(i32, D) }
1215        }
1216
1217        #[inline]
1218        unsafe fn decode(
1219            &mut self,
1220            decoder: &mut fidl::encoding::Decoder<'_, D>,
1221            offset: usize,
1222            _depth: fidl::encoding::Depth,
1223        ) -> fidl::Result<()> {
1224            decoder.debug_check_bounds::<Self>(offset);
1225            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1226            // Verify that padding bytes are zero.
1227            // Copy from the buffer into the object.
1228            unsafe {
1229                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1230            }
1231            Ok(())
1232        }
1233    }
1234
1235    impl fidl::encoding::ValueTypeMarker for DeviceChangePlugStateRequest {
1236        type Borrowed<'a> = &'a Self;
1237        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1238            value
1239        }
1240    }
1241
1242    unsafe impl fidl::encoding::TypeMarker for DeviceChangePlugStateRequest {
1243        type Owned = Self;
1244
1245        #[inline(always)]
1246        fn inline_align(_context: fidl::encoding::Context) -> usize {
1247            8
1248        }
1249
1250        #[inline(always)]
1251        fn inline_size(_context: fidl::encoding::Context) -> usize {
1252            16
1253        }
1254    }
1255
1256    unsafe impl<D: fidl::encoding::ResourceDialect>
1257        fidl::encoding::Encode<DeviceChangePlugStateRequest, D> for &DeviceChangePlugStateRequest
1258    {
1259        #[inline]
1260        unsafe fn encode(
1261            self,
1262            encoder: &mut fidl::encoding::Encoder<'_, D>,
1263            offset: usize,
1264            _depth: fidl::encoding::Depth,
1265        ) -> fidl::Result<()> {
1266            encoder.debug_check_bounds::<DeviceChangePlugStateRequest>(offset);
1267            // Delegate to tuple encoding.
1268            fidl::encoding::Encode::<DeviceChangePlugStateRequest, D>::encode(
1269                (
1270                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.plug_change_time),
1271                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.plugged),
1272                ),
1273                encoder,
1274                offset,
1275                _depth,
1276            )
1277        }
1278    }
1279    unsafe impl<
1280            D: fidl::encoding::ResourceDialect,
1281            T0: fidl::encoding::Encode<i64, D>,
1282            T1: fidl::encoding::Encode<bool, D>,
1283        > fidl::encoding::Encode<DeviceChangePlugStateRequest, D> for (T0, T1)
1284    {
1285        #[inline]
1286        unsafe fn encode(
1287            self,
1288            encoder: &mut fidl::encoding::Encoder<'_, D>,
1289            offset: usize,
1290            depth: fidl::encoding::Depth,
1291        ) -> fidl::Result<()> {
1292            encoder.debug_check_bounds::<DeviceChangePlugStateRequest>(offset);
1293            // Zero out padding regions. There's no need to apply masks
1294            // because the unmasked parts will be overwritten by fields.
1295            unsafe {
1296                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1297                (ptr as *mut u64).write_unaligned(0);
1298            }
1299            // Write the fields.
1300            self.0.encode(encoder, offset + 0, depth)?;
1301            self.1.encode(encoder, offset + 8, depth)?;
1302            Ok(())
1303        }
1304    }
1305
1306    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1307        for DeviceChangePlugStateRequest
1308    {
1309        #[inline(always)]
1310        fn new_empty() -> Self {
1311            Self { plug_change_time: fidl::new_empty!(i64, D), plugged: fidl::new_empty!(bool, D) }
1312        }
1313
1314        #[inline]
1315        unsafe fn decode(
1316            &mut self,
1317            decoder: &mut fidl::encoding::Decoder<'_, D>,
1318            offset: usize,
1319            _depth: fidl::encoding::Depth,
1320        ) -> fidl::Result<()> {
1321            decoder.debug_check_bounds::<Self>(offset);
1322            // Verify that padding bytes are zero.
1323            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
1324            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1325            let mask = 0xffffffffffffff00u64;
1326            let maskedval = padval & mask;
1327            if maskedval != 0 {
1328                return Err(fidl::Error::NonZeroPadding {
1329                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1330                });
1331            }
1332            fidl::decode!(i64, D, &mut self.plug_change_time, decoder, offset + 0, _depth)?;
1333            fidl::decode!(bool, D, &mut self.plugged, decoder, offset + 8, _depth)?;
1334            Ok(())
1335        }
1336    }
1337
1338    impl fidl::encoding::ValueTypeMarker for DeviceOnPositionNotifyRequest {
1339        type Borrowed<'a> = &'a Self;
1340        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1341            value
1342        }
1343    }
1344
1345    unsafe impl fidl::encoding::TypeMarker for DeviceOnPositionNotifyRequest {
1346        type Owned = Self;
1347
1348        #[inline(always)]
1349        fn inline_align(_context: fidl::encoding::Context) -> usize {
1350            8
1351        }
1352
1353        #[inline(always)]
1354        fn inline_size(_context: fidl::encoding::Context) -> usize {
1355            16
1356        }
1357    }
1358
1359    unsafe impl<D: fidl::encoding::ResourceDialect>
1360        fidl::encoding::Encode<DeviceOnPositionNotifyRequest, D>
1361        for &DeviceOnPositionNotifyRequest
1362    {
1363        #[inline]
1364        unsafe fn encode(
1365            self,
1366            encoder: &mut fidl::encoding::Encoder<'_, D>,
1367            offset: usize,
1368            _depth: fidl::encoding::Depth,
1369        ) -> fidl::Result<()> {
1370            encoder.debug_check_bounds::<DeviceOnPositionNotifyRequest>(offset);
1371            unsafe {
1372                // Copy the object into the buffer.
1373                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1374                (buf_ptr as *mut DeviceOnPositionNotifyRequest)
1375                    .write_unaligned((self as *const DeviceOnPositionNotifyRequest).read());
1376                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1377                // done second because the memcpy will write garbage to these bytes.
1378                let padding_ptr = buf_ptr.offset(8) as *mut u64;
1379                let padding_mask = 0xffffffff00000000u64;
1380                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1381            }
1382            Ok(())
1383        }
1384    }
1385    unsafe impl<
1386            D: fidl::encoding::ResourceDialect,
1387            T0: fidl::encoding::Encode<i64, D>,
1388            T1: fidl::encoding::Encode<u32, D>,
1389        > fidl::encoding::Encode<DeviceOnPositionNotifyRequest, D> for (T0, T1)
1390    {
1391        #[inline]
1392        unsafe fn encode(
1393            self,
1394            encoder: &mut fidl::encoding::Encoder<'_, D>,
1395            offset: usize,
1396            depth: fidl::encoding::Depth,
1397        ) -> fidl::Result<()> {
1398            encoder.debug_check_bounds::<DeviceOnPositionNotifyRequest>(offset);
1399            // Zero out padding regions. There's no need to apply masks
1400            // because the unmasked parts will be overwritten by fields.
1401            unsafe {
1402                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1403                (ptr as *mut u64).write_unaligned(0);
1404            }
1405            // Write the fields.
1406            self.0.encode(encoder, offset + 0, depth)?;
1407            self.1.encode(encoder, offset + 8, depth)?;
1408            Ok(())
1409        }
1410    }
1411
1412    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1413        for DeviceOnPositionNotifyRequest
1414    {
1415        #[inline(always)]
1416        fn new_empty() -> Self {
1417            Self {
1418                monotonic_time: fidl::new_empty!(i64, D),
1419                ring_position: fidl::new_empty!(u32, D),
1420            }
1421        }
1422
1423        #[inline]
1424        unsafe fn decode(
1425            &mut self,
1426            decoder: &mut fidl::encoding::Decoder<'_, D>,
1427            offset: usize,
1428            _depth: fidl::encoding::Depth,
1429        ) -> fidl::Result<()> {
1430            decoder.debug_check_bounds::<Self>(offset);
1431            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1432            // Verify that padding bytes are zero.
1433            let ptr = unsafe { buf_ptr.offset(8) };
1434            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1435            let mask = 0xffffffff00000000u64;
1436            let maskedval = padval & mask;
1437            if maskedval != 0 {
1438                return Err(fidl::Error::NonZeroPadding {
1439                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1440                });
1441            }
1442            // Copy from the buffer into the object.
1443            unsafe {
1444                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1445            }
1446            Ok(())
1447        }
1448    }
1449
1450    impl fidl::encoding::ValueTypeMarker for DeviceOnSetFormatRequest {
1451        type Borrowed<'a> = &'a Self;
1452        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1453            value
1454        }
1455    }
1456
1457    unsafe impl fidl::encoding::TypeMarker for DeviceOnSetFormatRequest {
1458        type Owned = Self;
1459
1460        #[inline(always)]
1461        fn inline_align(_context: fidl::encoding::Context) -> usize {
1462            8
1463        }
1464
1465        #[inline(always)]
1466        fn inline_size(_context: fidl::encoding::Context) -> usize {
1467            24
1468        }
1469    }
1470
1471    unsafe impl<D: fidl::encoding::ResourceDialect>
1472        fidl::encoding::Encode<DeviceOnSetFormatRequest, D> for &DeviceOnSetFormatRequest
1473    {
1474        #[inline]
1475        unsafe fn encode(
1476            self,
1477            encoder: &mut fidl::encoding::Encoder<'_, D>,
1478            offset: usize,
1479            _depth: fidl::encoding::Depth,
1480        ) -> fidl::Result<()> {
1481            encoder.debug_check_bounds::<DeviceOnSetFormatRequest>(offset);
1482            unsafe {
1483                // Copy the object into the buffer.
1484                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1485                (buf_ptr as *mut DeviceOnSetFormatRequest)
1486                    .write_unaligned((self as *const DeviceOnSetFormatRequest).read());
1487                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1488                // done second because the memcpy will write garbage to these bytes.
1489                let padding_ptr = buf_ptr.offset(8) as *mut u64;
1490                let padding_mask = 0xffffffff00000000u64;
1491                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1492            }
1493            Ok(())
1494        }
1495    }
1496    unsafe impl<
1497            D: fidl::encoding::ResourceDialect,
1498            T0: fidl::encoding::Encode<u32, D>,
1499            T1: fidl::encoding::Encode<u32, D>,
1500            T2: fidl::encoding::Encode<u32, D>,
1501            T3: fidl::encoding::Encode<i64, D>,
1502        > fidl::encoding::Encode<DeviceOnSetFormatRequest, D> for (T0, T1, T2, T3)
1503    {
1504        #[inline]
1505        unsafe fn encode(
1506            self,
1507            encoder: &mut fidl::encoding::Encoder<'_, D>,
1508            offset: usize,
1509            depth: fidl::encoding::Depth,
1510        ) -> fidl::Result<()> {
1511            encoder.debug_check_bounds::<DeviceOnSetFormatRequest>(offset);
1512            // Zero out padding regions. There's no need to apply masks
1513            // because the unmasked parts will be overwritten by fields.
1514            unsafe {
1515                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1516                (ptr as *mut u64).write_unaligned(0);
1517            }
1518            // Write the fields.
1519            self.0.encode(encoder, offset + 0, depth)?;
1520            self.1.encode(encoder, offset + 4, depth)?;
1521            self.2.encode(encoder, offset + 8, depth)?;
1522            self.3.encode(encoder, offset + 16, depth)?;
1523            Ok(())
1524        }
1525    }
1526
1527    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1528        for DeviceOnSetFormatRequest
1529    {
1530        #[inline(always)]
1531        fn new_empty() -> Self {
1532            Self {
1533                frames_per_second: fidl::new_empty!(u32, D),
1534                sample_format: fidl::new_empty!(u32, D),
1535                num_channels: fidl::new_empty!(u32, D),
1536                external_delay: fidl::new_empty!(i64, D),
1537            }
1538        }
1539
1540        #[inline]
1541        unsafe fn decode(
1542            &mut self,
1543            decoder: &mut fidl::encoding::Decoder<'_, D>,
1544            offset: usize,
1545            _depth: fidl::encoding::Depth,
1546        ) -> fidl::Result<()> {
1547            decoder.debug_check_bounds::<Self>(offset);
1548            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1549            // Verify that padding bytes are zero.
1550            let ptr = unsafe { buf_ptr.offset(8) };
1551            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1552            let mask = 0xffffffff00000000u64;
1553            let maskedval = padval & mask;
1554            if maskedval != 0 {
1555                return Err(fidl::Error::NonZeroPadding {
1556                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1557                });
1558            }
1559            // Copy from the buffer into the object.
1560            unsafe {
1561                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
1562            }
1563            Ok(())
1564        }
1565    }
1566
1567    impl fidl::encoding::ValueTypeMarker for DeviceOnSetGainRequest {
1568        type Borrowed<'a> = &'a Self;
1569        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1570            value
1571        }
1572    }
1573
1574    unsafe impl fidl::encoding::TypeMarker for DeviceOnSetGainRequest {
1575        type Owned = Self;
1576
1577        #[inline(always)]
1578        fn inline_align(_context: fidl::encoding::Context) -> usize {
1579            4
1580        }
1581
1582        #[inline(always)]
1583        fn inline_size(_context: fidl::encoding::Context) -> usize {
1584            8
1585        }
1586    }
1587
1588    unsafe impl<D: fidl::encoding::ResourceDialect>
1589        fidl::encoding::Encode<DeviceOnSetGainRequest, D> for &DeviceOnSetGainRequest
1590    {
1591        #[inline]
1592        unsafe fn encode(
1593            self,
1594            encoder: &mut fidl::encoding::Encoder<'_, D>,
1595            offset: usize,
1596            _depth: fidl::encoding::Depth,
1597        ) -> fidl::Result<()> {
1598            encoder.debug_check_bounds::<DeviceOnSetGainRequest>(offset);
1599            // Delegate to tuple encoding.
1600            fidl::encoding::Encode::<DeviceOnSetGainRequest, D>::encode(
1601                (
1602                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.current_mute),
1603                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.current_agc),
1604                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.current_gain_db),
1605                ),
1606                encoder,
1607                offset,
1608                _depth,
1609            )
1610        }
1611    }
1612    unsafe impl<
1613            D: fidl::encoding::ResourceDialect,
1614            T0: fidl::encoding::Encode<bool, D>,
1615            T1: fidl::encoding::Encode<bool, D>,
1616            T2: fidl::encoding::Encode<f32, D>,
1617        > fidl::encoding::Encode<DeviceOnSetGainRequest, D> for (T0, T1, T2)
1618    {
1619        #[inline]
1620        unsafe fn encode(
1621            self,
1622            encoder: &mut fidl::encoding::Encoder<'_, D>,
1623            offset: usize,
1624            depth: fidl::encoding::Depth,
1625        ) -> fidl::Result<()> {
1626            encoder.debug_check_bounds::<DeviceOnSetGainRequest>(offset);
1627            // Zero out padding regions. There's no need to apply masks
1628            // because the unmasked parts will be overwritten by fields.
1629            unsafe {
1630                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1631                (ptr as *mut u32).write_unaligned(0);
1632            }
1633            // Write the fields.
1634            self.0.encode(encoder, offset + 0, depth)?;
1635            self.1.encode(encoder, offset + 1, depth)?;
1636            self.2.encode(encoder, offset + 4, depth)?;
1637            Ok(())
1638        }
1639    }
1640
1641    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1642        for DeviceOnSetGainRequest
1643    {
1644        #[inline(always)]
1645        fn new_empty() -> Self {
1646            Self {
1647                current_mute: fidl::new_empty!(bool, D),
1648                current_agc: fidl::new_empty!(bool, D),
1649                current_gain_db: fidl::new_empty!(f32, D),
1650            }
1651        }
1652
1653        #[inline]
1654        unsafe fn decode(
1655            &mut self,
1656            decoder: &mut fidl::encoding::Decoder<'_, D>,
1657            offset: usize,
1658            _depth: fidl::encoding::Depth,
1659        ) -> fidl::Result<()> {
1660            decoder.debug_check_bounds::<Self>(offset);
1661            // Verify that padding bytes are zero.
1662            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1663            let padval = unsafe { (ptr as *const u32).read_unaligned() };
1664            let mask = 0xffff0000u32;
1665            let maskedval = padval & mask;
1666            if maskedval != 0 {
1667                return Err(fidl::Error::NonZeroPadding {
1668                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1669                });
1670            }
1671            fidl::decode!(bool, D, &mut self.current_mute, decoder, offset + 0, _depth)?;
1672            fidl::decode!(bool, D, &mut self.current_agc, decoder, offset + 1, _depth)?;
1673            fidl::decode!(f32, D, &mut self.current_gain_db, decoder, offset + 4, _depth)?;
1674            Ok(())
1675        }
1676    }
1677
1678    impl fidl::encoding::ValueTypeMarker for DeviceOnStartRequest {
1679        type Borrowed<'a> = &'a Self;
1680        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1681            value
1682        }
1683    }
1684
1685    unsafe impl fidl::encoding::TypeMarker for DeviceOnStartRequest {
1686        type Owned = Self;
1687
1688        #[inline(always)]
1689        fn inline_align(_context: fidl::encoding::Context) -> usize {
1690            8
1691        }
1692
1693        #[inline(always)]
1694        fn inline_size(_context: fidl::encoding::Context) -> usize {
1695            8
1696        }
1697        #[inline(always)]
1698        fn encode_is_copy() -> bool {
1699            true
1700        }
1701
1702        #[inline(always)]
1703        fn decode_is_copy() -> bool {
1704            true
1705        }
1706    }
1707
1708    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceOnStartRequest, D>
1709        for &DeviceOnStartRequest
1710    {
1711        #[inline]
1712        unsafe fn encode(
1713            self,
1714            encoder: &mut fidl::encoding::Encoder<'_, D>,
1715            offset: usize,
1716            _depth: fidl::encoding::Depth,
1717        ) -> fidl::Result<()> {
1718            encoder.debug_check_bounds::<DeviceOnStartRequest>(offset);
1719            unsafe {
1720                // Copy the object into the buffer.
1721                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1722                (buf_ptr as *mut DeviceOnStartRequest)
1723                    .write_unaligned((self as *const DeviceOnStartRequest).read());
1724                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1725                // done second because the memcpy will write garbage to these bytes.
1726            }
1727            Ok(())
1728        }
1729    }
1730    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
1731        fidl::encoding::Encode<DeviceOnStartRequest, D> for (T0,)
1732    {
1733        #[inline]
1734        unsafe fn encode(
1735            self,
1736            encoder: &mut fidl::encoding::Encoder<'_, D>,
1737            offset: usize,
1738            depth: fidl::encoding::Depth,
1739        ) -> fidl::Result<()> {
1740            encoder.debug_check_bounds::<DeviceOnStartRequest>(offset);
1741            // Zero out padding regions. There's no need to apply masks
1742            // because the unmasked parts will be overwritten by fields.
1743            // Write the fields.
1744            self.0.encode(encoder, offset + 0, depth)?;
1745            Ok(())
1746        }
1747    }
1748
1749    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceOnStartRequest {
1750        #[inline(always)]
1751        fn new_empty() -> Self {
1752            Self { start_time: fidl::new_empty!(i64, D) }
1753        }
1754
1755        #[inline]
1756        unsafe fn decode(
1757            &mut self,
1758            decoder: &mut fidl::encoding::Decoder<'_, D>,
1759            offset: usize,
1760            _depth: fidl::encoding::Depth,
1761        ) -> fidl::Result<()> {
1762            decoder.debug_check_bounds::<Self>(offset);
1763            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1764            // Verify that padding bytes are zero.
1765            // Copy from the buffer into the object.
1766            unsafe {
1767                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1768            }
1769            Ok(())
1770        }
1771    }
1772
1773    impl fidl::encoding::ValueTypeMarker for DeviceOnStopRequest {
1774        type Borrowed<'a> = &'a Self;
1775        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1776            value
1777        }
1778    }
1779
1780    unsafe impl fidl::encoding::TypeMarker for DeviceOnStopRequest {
1781        type Owned = Self;
1782
1783        #[inline(always)]
1784        fn inline_align(_context: fidl::encoding::Context) -> usize {
1785            8
1786        }
1787
1788        #[inline(always)]
1789        fn inline_size(_context: fidl::encoding::Context) -> usize {
1790            16
1791        }
1792    }
1793
1794    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceOnStopRequest, D>
1795        for &DeviceOnStopRequest
1796    {
1797        #[inline]
1798        unsafe fn encode(
1799            self,
1800            encoder: &mut fidl::encoding::Encoder<'_, D>,
1801            offset: usize,
1802            _depth: fidl::encoding::Depth,
1803        ) -> fidl::Result<()> {
1804            encoder.debug_check_bounds::<DeviceOnStopRequest>(offset);
1805            unsafe {
1806                // Copy the object into the buffer.
1807                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1808                (buf_ptr as *mut DeviceOnStopRequest)
1809                    .write_unaligned((self as *const DeviceOnStopRequest).read());
1810                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1811                // done second because the memcpy will write garbage to these bytes.
1812                let padding_ptr = buf_ptr.offset(8) as *mut u64;
1813                let padding_mask = 0xffffffff00000000u64;
1814                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1815            }
1816            Ok(())
1817        }
1818    }
1819    unsafe impl<
1820            D: fidl::encoding::ResourceDialect,
1821            T0: fidl::encoding::Encode<i64, D>,
1822            T1: fidl::encoding::Encode<u32, D>,
1823        > fidl::encoding::Encode<DeviceOnStopRequest, D> for (T0, T1)
1824    {
1825        #[inline]
1826        unsafe fn encode(
1827            self,
1828            encoder: &mut fidl::encoding::Encoder<'_, D>,
1829            offset: usize,
1830            depth: fidl::encoding::Depth,
1831        ) -> fidl::Result<()> {
1832            encoder.debug_check_bounds::<DeviceOnStopRequest>(offset);
1833            // Zero out padding regions. There's no need to apply masks
1834            // because the unmasked parts will be overwritten by fields.
1835            unsafe {
1836                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
1837                (ptr as *mut u64).write_unaligned(0);
1838            }
1839            // Write the fields.
1840            self.0.encode(encoder, offset + 0, depth)?;
1841            self.1.encode(encoder, offset + 8, depth)?;
1842            Ok(())
1843        }
1844    }
1845
1846    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceOnStopRequest {
1847        #[inline(always)]
1848        fn new_empty() -> Self {
1849            Self { stop_time: fidl::new_empty!(i64, D), ring_position: fidl::new_empty!(u32, D) }
1850        }
1851
1852        #[inline]
1853        unsafe fn decode(
1854            &mut self,
1855            decoder: &mut fidl::encoding::Decoder<'_, D>,
1856            offset: usize,
1857            _depth: fidl::encoding::Depth,
1858        ) -> fidl::Result<()> {
1859            decoder.debug_check_bounds::<Self>(offset);
1860            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1861            // Verify that padding bytes are zero.
1862            let ptr = unsafe { buf_ptr.offset(8) };
1863            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1864            let mask = 0xffffffff00000000u64;
1865            let maskedval = padval & mask;
1866            if maskedval != 0 {
1867                return Err(fidl::Error::NonZeroPadding {
1868                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
1869                });
1870            }
1871            // Copy from the buffer into the object.
1872            unsafe {
1873                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1874            }
1875            Ok(())
1876        }
1877    }
1878
1879    impl fidl::encoding::ValueTypeMarker for DeviceSetNotificationFrequencyRequest {
1880        type Borrowed<'a> = &'a Self;
1881        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1882            value
1883        }
1884    }
1885
1886    unsafe impl fidl::encoding::TypeMarker for DeviceSetNotificationFrequencyRequest {
1887        type Owned = Self;
1888
1889        #[inline(always)]
1890        fn inline_align(_context: fidl::encoding::Context) -> usize {
1891            4
1892        }
1893
1894        #[inline(always)]
1895        fn inline_size(_context: fidl::encoding::Context) -> usize {
1896            4
1897        }
1898        #[inline(always)]
1899        fn encode_is_copy() -> bool {
1900            true
1901        }
1902
1903        #[inline(always)]
1904        fn decode_is_copy() -> bool {
1905            true
1906        }
1907    }
1908
1909    unsafe impl<D: fidl::encoding::ResourceDialect>
1910        fidl::encoding::Encode<DeviceSetNotificationFrequencyRequest, D>
1911        for &DeviceSetNotificationFrequencyRequest
1912    {
1913        #[inline]
1914        unsafe fn encode(
1915            self,
1916            encoder: &mut fidl::encoding::Encoder<'_, D>,
1917            offset: usize,
1918            _depth: fidl::encoding::Depth,
1919        ) -> fidl::Result<()> {
1920            encoder.debug_check_bounds::<DeviceSetNotificationFrequencyRequest>(offset);
1921            unsafe {
1922                // Copy the object into the buffer.
1923                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1924                (buf_ptr as *mut DeviceSetNotificationFrequencyRequest)
1925                    .write_unaligned((self as *const DeviceSetNotificationFrequencyRequest).read());
1926                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1927                // done second because the memcpy will write garbage to these bytes.
1928            }
1929            Ok(())
1930        }
1931    }
1932    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1933        fidl::encoding::Encode<DeviceSetNotificationFrequencyRequest, D> for (T0,)
1934    {
1935        #[inline]
1936        unsafe fn encode(
1937            self,
1938            encoder: &mut fidl::encoding::Encoder<'_, D>,
1939            offset: usize,
1940            depth: fidl::encoding::Depth,
1941        ) -> fidl::Result<()> {
1942            encoder.debug_check_bounds::<DeviceSetNotificationFrequencyRequest>(offset);
1943            // Zero out padding regions. There's no need to apply masks
1944            // because the unmasked parts will be overwritten by fields.
1945            // Write the fields.
1946            self.0.encode(encoder, offset + 0, depth)?;
1947            Ok(())
1948        }
1949    }
1950
1951    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1952        for DeviceSetNotificationFrequencyRequest
1953    {
1954        #[inline(always)]
1955        fn new_empty() -> Self {
1956            Self { notifications_per_ring: fidl::new_empty!(u32, D) }
1957        }
1958
1959        #[inline]
1960        unsafe fn decode(
1961            &mut self,
1962            decoder: &mut fidl::encoding::Decoder<'_, D>,
1963            offset: usize,
1964            _depth: fidl::encoding::Depth,
1965        ) -> fidl::Result<()> {
1966            decoder.debug_check_bounds::<Self>(offset);
1967            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1968            // Verify that padding bytes are zero.
1969            // Copy from the buffer into the object.
1970            unsafe {
1971                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1972            }
1973            Ok(())
1974        }
1975    }
1976
1977    impl fidl::encoding::ValueTypeMarker for DeviceGetFormatResponse {
1978        type Borrowed<'a> = &'a Self;
1979        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1980            value
1981        }
1982    }
1983
1984    unsafe impl fidl::encoding::TypeMarker for DeviceGetFormatResponse {
1985        type Owned = Self;
1986
1987        #[inline(always)]
1988        fn inline_align(_context: fidl::encoding::Context) -> usize {
1989            8
1990        }
1991
1992        #[inline(always)]
1993        fn inline_size(_context: fidl::encoding::Context) -> usize {
1994            24
1995        }
1996    }
1997
1998    unsafe impl<D: fidl::encoding::ResourceDialect>
1999        fidl::encoding::Encode<DeviceGetFormatResponse, D> for &DeviceGetFormatResponse
2000    {
2001        #[inline]
2002        unsafe fn encode(
2003            self,
2004            encoder: &mut fidl::encoding::Encoder<'_, D>,
2005            offset: usize,
2006            _depth: fidl::encoding::Depth,
2007        ) -> fidl::Result<()> {
2008            encoder.debug_check_bounds::<DeviceGetFormatResponse>(offset);
2009            unsafe {
2010                // Copy the object into the buffer.
2011                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2012                (buf_ptr as *mut DeviceGetFormatResponse)
2013                    .write_unaligned((self as *const DeviceGetFormatResponse).read());
2014                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2015                // done second because the memcpy will write garbage to these bytes.
2016                let padding_ptr = buf_ptr.offset(8) as *mut u64;
2017                let padding_mask = 0xffffffff00000000u64;
2018                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2019            }
2020            Ok(())
2021        }
2022    }
2023    unsafe impl<
2024            D: fidl::encoding::ResourceDialect,
2025            T0: fidl::encoding::Encode<u32, D>,
2026            T1: fidl::encoding::Encode<u32, D>,
2027            T2: fidl::encoding::Encode<u32, D>,
2028            T3: fidl::encoding::Encode<i64, D>,
2029        > fidl::encoding::Encode<DeviceGetFormatResponse, D> for (T0, T1, T2, T3)
2030    {
2031        #[inline]
2032        unsafe fn encode(
2033            self,
2034            encoder: &mut fidl::encoding::Encoder<'_, D>,
2035            offset: usize,
2036            depth: fidl::encoding::Depth,
2037        ) -> fidl::Result<()> {
2038            encoder.debug_check_bounds::<DeviceGetFormatResponse>(offset);
2039            // Zero out padding regions. There's no need to apply masks
2040            // because the unmasked parts will be overwritten by fields.
2041            unsafe {
2042                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2043                (ptr as *mut u64).write_unaligned(0);
2044            }
2045            // Write the fields.
2046            self.0.encode(encoder, offset + 0, depth)?;
2047            self.1.encode(encoder, offset + 4, depth)?;
2048            self.2.encode(encoder, offset + 8, depth)?;
2049            self.3.encode(encoder, offset + 16, depth)?;
2050            Ok(())
2051        }
2052    }
2053
2054    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2055        for DeviceGetFormatResponse
2056    {
2057        #[inline(always)]
2058        fn new_empty() -> Self {
2059            Self {
2060                frames_per_second: fidl::new_empty!(u32, D),
2061                sample_format: fidl::new_empty!(u32, D),
2062                num_channels: fidl::new_empty!(u32, D),
2063                external_delay: fidl::new_empty!(i64, D),
2064            }
2065        }
2066
2067        #[inline]
2068        unsafe fn decode(
2069            &mut self,
2070            decoder: &mut fidl::encoding::Decoder<'_, D>,
2071            offset: usize,
2072            _depth: fidl::encoding::Depth,
2073        ) -> fidl::Result<()> {
2074            decoder.debug_check_bounds::<Self>(offset);
2075            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2076            // Verify that padding bytes are zero.
2077            let ptr = unsafe { buf_ptr.offset(8) };
2078            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2079            let mask = 0xffffffff00000000u64;
2080            let maskedval = padval & mask;
2081            if maskedval != 0 {
2082                return Err(fidl::Error::NonZeroPadding {
2083                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2084                });
2085            }
2086            // Copy from the buffer into the object.
2087            unsafe {
2088                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
2089            }
2090            Ok(())
2091        }
2092    }
2093
2094    impl fidl::encoding::ValueTypeMarker for DeviceGetGainResponse {
2095        type Borrowed<'a> = &'a Self;
2096        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2097            value
2098        }
2099    }
2100
2101    unsafe impl fidl::encoding::TypeMarker for DeviceGetGainResponse {
2102        type Owned = Self;
2103
2104        #[inline(always)]
2105        fn inline_align(_context: fidl::encoding::Context) -> usize {
2106            4
2107        }
2108
2109        #[inline(always)]
2110        fn inline_size(_context: fidl::encoding::Context) -> usize {
2111            8
2112        }
2113    }
2114
2115    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceGetGainResponse, D>
2116        for &DeviceGetGainResponse
2117    {
2118        #[inline]
2119        unsafe fn encode(
2120            self,
2121            encoder: &mut fidl::encoding::Encoder<'_, D>,
2122            offset: usize,
2123            _depth: fidl::encoding::Depth,
2124        ) -> fidl::Result<()> {
2125            encoder.debug_check_bounds::<DeviceGetGainResponse>(offset);
2126            // Delegate to tuple encoding.
2127            fidl::encoding::Encode::<DeviceGetGainResponse, D>::encode(
2128                (
2129                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.current_mute),
2130                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.current_agc),
2131                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.current_gain_db),
2132                ),
2133                encoder,
2134                offset,
2135                _depth,
2136            )
2137        }
2138    }
2139    unsafe impl<
2140            D: fidl::encoding::ResourceDialect,
2141            T0: fidl::encoding::Encode<bool, D>,
2142            T1: fidl::encoding::Encode<bool, D>,
2143            T2: fidl::encoding::Encode<f32, D>,
2144        > fidl::encoding::Encode<DeviceGetGainResponse, D> for (T0, T1, T2)
2145    {
2146        #[inline]
2147        unsafe fn encode(
2148            self,
2149            encoder: &mut fidl::encoding::Encoder<'_, D>,
2150            offset: usize,
2151            depth: fidl::encoding::Depth,
2152        ) -> fidl::Result<()> {
2153            encoder.debug_check_bounds::<DeviceGetGainResponse>(offset);
2154            // Zero out padding regions. There's no need to apply masks
2155            // because the unmasked parts will be overwritten by fields.
2156            unsafe {
2157                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2158                (ptr as *mut u32).write_unaligned(0);
2159            }
2160            // Write the fields.
2161            self.0.encode(encoder, offset + 0, depth)?;
2162            self.1.encode(encoder, offset + 1, depth)?;
2163            self.2.encode(encoder, offset + 4, depth)?;
2164            Ok(())
2165        }
2166    }
2167
2168    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceGetGainResponse {
2169        #[inline(always)]
2170        fn new_empty() -> Self {
2171            Self {
2172                current_mute: fidl::new_empty!(bool, D),
2173                current_agc: fidl::new_empty!(bool, D),
2174                current_gain_db: fidl::new_empty!(f32, D),
2175            }
2176        }
2177
2178        #[inline]
2179        unsafe fn decode(
2180            &mut self,
2181            decoder: &mut fidl::encoding::Decoder<'_, D>,
2182            offset: usize,
2183            _depth: fidl::encoding::Depth,
2184        ) -> fidl::Result<()> {
2185            decoder.debug_check_bounds::<Self>(offset);
2186            // Verify that padding bytes are zero.
2187            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2188            let padval = unsafe { (ptr as *const u32).read_unaligned() };
2189            let mask = 0xffff0000u32;
2190            let maskedval = padval & mask;
2191            if maskedval != 0 {
2192                return Err(fidl::Error::NonZeroPadding {
2193                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2194                });
2195            }
2196            fidl::decode!(bool, D, &mut self.current_mute, decoder, offset + 0, _depth)?;
2197            fidl::decode!(bool, D, &mut self.current_agc, decoder, offset + 1, _depth)?;
2198            fidl::decode!(f32, D, &mut self.current_gain_db, decoder, offset + 4, _depth)?;
2199            Ok(())
2200        }
2201    }
2202
2203    impl fidl::encoding::ValueTypeMarker for DeviceGetPositionResponse {
2204        type Borrowed<'a> = &'a Self;
2205        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2206            value
2207        }
2208    }
2209
2210    unsafe impl fidl::encoding::TypeMarker for DeviceGetPositionResponse {
2211        type Owned = Self;
2212
2213        #[inline(always)]
2214        fn inline_align(_context: fidl::encoding::Context) -> usize {
2215            8
2216        }
2217
2218        #[inline(always)]
2219        fn inline_size(_context: fidl::encoding::Context) -> usize {
2220            16
2221        }
2222    }
2223
2224    unsafe impl<D: fidl::encoding::ResourceDialect>
2225        fidl::encoding::Encode<DeviceGetPositionResponse, D> for &DeviceGetPositionResponse
2226    {
2227        #[inline]
2228        unsafe fn encode(
2229            self,
2230            encoder: &mut fidl::encoding::Encoder<'_, D>,
2231            offset: usize,
2232            _depth: fidl::encoding::Depth,
2233        ) -> fidl::Result<()> {
2234            encoder.debug_check_bounds::<DeviceGetPositionResponse>(offset);
2235            unsafe {
2236                // Copy the object into the buffer.
2237                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2238                (buf_ptr as *mut DeviceGetPositionResponse)
2239                    .write_unaligned((self as *const DeviceGetPositionResponse).read());
2240                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2241                // done second because the memcpy will write garbage to these bytes.
2242                let padding_ptr = buf_ptr.offset(8) as *mut u64;
2243                let padding_mask = 0xffffffff00000000u64;
2244                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2245            }
2246            Ok(())
2247        }
2248    }
2249    unsafe impl<
2250            D: fidl::encoding::ResourceDialect,
2251            T0: fidl::encoding::Encode<i64, D>,
2252            T1: fidl::encoding::Encode<u32, D>,
2253        > fidl::encoding::Encode<DeviceGetPositionResponse, D> for (T0, T1)
2254    {
2255        #[inline]
2256        unsafe fn encode(
2257            self,
2258            encoder: &mut fidl::encoding::Encoder<'_, D>,
2259            offset: usize,
2260            depth: fidl::encoding::Depth,
2261        ) -> fidl::Result<()> {
2262            encoder.debug_check_bounds::<DeviceGetPositionResponse>(offset);
2263            // Zero out padding regions. There's no need to apply masks
2264            // because the unmasked parts will be overwritten by fields.
2265            unsafe {
2266                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2267                (ptr as *mut u64).write_unaligned(0);
2268            }
2269            // Write the fields.
2270            self.0.encode(encoder, offset + 0, depth)?;
2271            self.1.encode(encoder, offset + 8, depth)?;
2272            Ok(())
2273        }
2274    }
2275
2276    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2277        for DeviceGetPositionResponse
2278    {
2279        #[inline(always)]
2280        fn new_empty() -> Self {
2281            Self {
2282                monotonic_time: fidl::new_empty!(i64, D),
2283                ring_position: fidl::new_empty!(u32, D),
2284            }
2285        }
2286
2287        #[inline]
2288        unsafe fn decode(
2289            &mut self,
2290            decoder: &mut fidl::encoding::Decoder<'_, D>,
2291            offset: usize,
2292            _depth: fidl::encoding::Depth,
2293        ) -> fidl::Result<()> {
2294            decoder.debug_check_bounds::<Self>(offset);
2295            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2296            // Verify that padding bytes are zero.
2297            let ptr = unsafe { buf_ptr.offset(8) };
2298            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2299            let mask = 0xffffffff00000000u64;
2300            let maskedval = padval & mask;
2301            if maskedval != 0 {
2302                return Err(fidl::Error::NonZeroPadding {
2303                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2304                });
2305            }
2306            // Copy from the buffer into the object.
2307            unsafe {
2308                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2309            }
2310            Ok(())
2311        }
2312    }
2313
2314    impl fidl::encoding::ValueTypeMarker for FormatRange {
2315        type Borrowed<'a> = &'a Self;
2316        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2317            value
2318        }
2319    }
2320
2321    unsafe impl fidl::encoding::TypeMarker for FormatRange {
2322        type Owned = Self;
2323
2324        #[inline(always)]
2325        fn inline_align(_context: fidl::encoding::Context) -> usize {
2326            4
2327        }
2328
2329        #[inline(always)]
2330        fn inline_size(_context: fidl::encoding::Context) -> usize {
2331            16
2332        }
2333        #[inline(always)]
2334        fn encode_is_copy() -> bool {
2335            true
2336        }
2337
2338        #[inline(always)]
2339        fn decode_is_copy() -> bool {
2340            true
2341        }
2342    }
2343
2344    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatRange, D>
2345        for &FormatRange
2346    {
2347        #[inline]
2348        unsafe fn encode(
2349            self,
2350            encoder: &mut fidl::encoding::Encoder<'_, D>,
2351            offset: usize,
2352            _depth: fidl::encoding::Depth,
2353        ) -> fidl::Result<()> {
2354            encoder.debug_check_bounds::<FormatRange>(offset);
2355            unsafe {
2356                // Copy the object into the buffer.
2357                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2358                (buf_ptr as *mut FormatRange).write_unaligned((self as *const FormatRange).read());
2359                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2360                // done second because the memcpy will write garbage to these bytes.
2361            }
2362            Ok(())
2363        }
2364    }
2365    unsafe impl<
2366            D: fidl::encoding::ResourceDialect,
2367            T0: fidl::encoding::Encode<u32, D>,
2368            T1: fidl::encoding::Encode<u32, D>,
2369            T2: fidl::encoding::Encode<u32, D>,
2370            T3: fidl::encoding::Encode<u8, D>,
2371            T4: fidl::encoding::Encode<u8, D>,
2372            T5: fidl::encoding::Encode<u16, D>,
2373        > fidl::encoding::Encode<FormatRange, D> for (T0, T1, T2, T3, T4, T5)
2374    {
2375        #[inline]
2376        unsafe fn encode(
2377            self,
2378            encoder: &mut fidl::encoding::Encoder<'_, D>,
2379            offset: usize,
2380            depth: fidl::encoding::Depth,
2381        ) -> fidl::Result<()> {
2382            encoder.debug_check_bounds::<FormatRange>(offset);
2383            // Zero out padding regions. There's no need to apply masks
2384            // because the unmasked parts will be overwritten by fields.
2385            // Write the fields.
2386            self.0.encode(encoder, offset + 0, depth)?;
2387            self.1.encode(encoder, offset + 4, depth)?;
2388            self.2.encode(encoder, offset + 8, depth)?;
2389            self.3.encode(encoder, offset + 12, depth)?;
2390            self.4.encode(encoder, offset + 13, depth)?;
2391            self.5.encode(encoder, offset + 14, depth)?;
2392            Ok(())
2393        }
2394    }
2395
2396    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatRange {
2397        #[inline(always)]
2398        fn new_empty() -> Self {
2399            Self {
2400                sample_format_flags: fidl::new_empty!(u32, D),
2401                min_frame_rate: fidl::new_empty!(u32, D),
2402                max_frame_rate: fidl::new_empty!(u32, D),
2403                min_channels: fidl::new_empty!(u8, D),
2404                max_channels: fidl::new_empty!(u8, D),
2405                rate_family_flags: fidl::new_empty!(u16, D),
2406            }
2407        }
2408
2409        #[inline]
2410        unsafe fn decode(
2411            &mut self,
2412            decoder: &mut fidl::encoding::Decoder<'_, D>,
2413            offset: usize,
2414            _depth: fidl::encoding::Depth,
2415        ) -> fidl::Result<()> {
2416            decoder.debug_check_bounds::<Self>(offset);
2417            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2418            // Verify that padding bytes are zero.
2419            // Copy from the buffer into the object.
2420            unsafe {
2421                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2422            }
2423            Ok(())
2424        }
2425    }
2426
2427    impl fidl::encoding::ValueTypeMarker for RingBufferConstraints {
2428        type Borrowed<'a> = &'a Self;
2429        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2430            value
2431        }
2432    }
2433
2434    unsafe impl fidl::encoding::TypeMarker for RingBufferConstraints {
2435        type Owned = Self;
2436
2437        #[inline(always)]
2438        fn inline_align(_context: fidl::encoding::Context) -> usize {
2439            4
2440        }
2441
2442        #[inline(always)]
2443        fn inline_size(_context: fidl::encoding::Context) -> usize {
2444            12
2445        }
2446        #[inline(always)]
2447        fn encode_is_copy() -> bool {
2448            true
2449        }
2450
2451        #[inline(always)]
2452        fn decode_is_copy() -> bool {
2453            true
2454        }
2455    }
2456
2457    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferConstraints, D>
2458        for &RingBufferConstraints
2459    {
2460        #[inline]
2461        unsafe fn encode(
2462            self,
2463            encoder: &mut fidl::encoding::Encoder<'_, D>,
2464            offset: usize,
2465            _depth: fidl::encoding::Depth,
2466        ) -> fidl::Result<()> {
2467            encoder.debug_check_bounds::<RingBufferConstraints>(offset);
2468            unsafe {
2469                // Copy the object into the buffer.
2470                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2471                (buf_ptr as *mut RingBufferConstraints)
2472                    .write_unaligned((self as *const RingBufferConstraints).read());
2473                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2474                // done second because the memcpy will write garbage to these bytes.
2475            }
2476            Ok(())
2477        }
2478    }
2479    unsafe impl<
2480            D: fidl::encoding::ResourceDialect,
2481            T0: fidl::encoding::Encode<u32, D>,
2482            T1: fidl::encoding::Encode<u32, D>,
2483            T2: fidl::encoding::Encode<u32, D>,
2484        > fidl::encoding::Encode<RingBufferConstraints, D> for (T0, T1, T2)
2485    {
2486        #[inline]
2487        unsafe fn encode(
2488            self,
2489            encoder: &mut fidl::encoding::Encoder<'_, D>,
2490            offset: usize,
2491            depth: fidl::encoding::Depth,
2492        ) -> fidl::Result<()> {
2493            encoder.debug_check_bounds::<RingBufferConstraints>(offset);
2494            // Zero out padding regions. There's no need to apply masks
2495            // because the unmasked parts will be overwritten by fields.
2496            // Write the fields.
2497            self.0.encode(encoder, offset + 0, depth)?;
2498            self.1.encode(encoder, offset + 4, depth)?;
2499            self.2.encode(encoder, offset + 8, depth)?;
2500            Ok(())
2501        }
2502    }
2503
2504    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferConstraints {
2505        #[inline(always)]
2506        fn new_empty() -> Self {
2507            Self {
2508                min_frames: fidl::new_empty!(u32, D),
2509                max_frames: fidl::new_empty!(u32, D),
2510                modulo_frames: fidl::new_empty!(u32, D),
2511            }
2512        }
2513
2514        #[inline]
2515        unsafe fn decode(
2516            &mut self,
2517            decoder: &mut fidl::encoding::Decoder<'_, D>,
2518            offset: usize,
2519            _depth: fidl::encoding::Depth,
2520        ) -> fidl::Result<()> {
2521            decoder.debug_check_bounds::<Self>(offset);
2522            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2523            // Verify that padding bytes are zero.
2524            // Copy from the buffer into the object.
2525            unsafe {
2526                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
2527            }
2528            Ok(())
2529        }
2530    }
2531
2532    impl ClockProperties {
2533        #[inline(always)]
2534        fn max_ordinal_present(&self) -> u64 {
2535            if let Some(_) = self.rate_adjustment_ppm {
2536                return 2;
2537            }
2538            if let Some(_) = self.domain {
2539                return 1;
2540            }
2541            0
2542        }
2543    }
2544
2545    impl fidl::encoding::ValueTypeMarker for ClockProperties {
2546        type Borrowed<'a> = &'a Self;
2547        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2548            value
2549        }
2550    }
2551
2552    unsafe impl fidl::encoding::TypeMarker for ClockProperties {
2553        type Owned = Self;
2554
2555        #[inline(always)]
2556        fn inline_align(_context: fidl::encoding::Context) -> usize {
2557            8
2558        }
2559
2560        #[inline(always)]
2561        fn inline_size(_context: fidl::encoding::Context) -> usize {
2562            16
2563        }
2564    }
2565
2566    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClockProperties, D>
2567        for &ClockProperties
2568    {
2569        unsafe fn encode(
2570            self,
2571            encoder: &mut fidl::encoding::Encoder<'_, D>,
2572            offset: usize,
2573            mut depth: fidl::encoding::Depth,
2574        ) -> fidl::Result<()> {
2575            encoder.debug_check_bounds::<ClockProperties>(offset);
2576            // Vector header
2577            let max_ordinal: u64 = self.max_ordinal_present();
2578            encoder.write_num(max_ordinal, offset);
2579            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2580            // Calling encoder.out_of_line_offset(0) is not allowed.
2581            if max_ordinal == 0 {
2582                return Ok(());
2583            }
2584            depth.increment()?;
2585            let envelope_size = 8;
2586            let bytes_len = max_ordinal as usize * envelope_size;
2587            #[allow(unused_variables)]
2588            let offset = encoder.out_of_line_offset(bytes_len);
2589            let mut _prev_end_offset: usize = 0;
2590            if 1 > max_ordinal {
2591                return Ok(());
2592            }
2593
2594            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2595            // are envelope_size bytes.
2596            let cur_offset: usize = (1 - 1) * envelope_size;
2597
2598            // Zero reserved fields.
2599            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2600
2601            // Safety:
2602            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2603            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2604            //   envelope_size bytes, there is always sufficient room.
2605            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2606                self.domain.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2607                encoder,
2608                offset + cur_offset,
2609                depth,
2610            )?;
2611
2612            _prev_end_offset = cur_offset + envelope_size;
2613            if 2 > max_ordinal {
2614                return Ok(());
2615            }
2616
2617            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2618            // are envelope_size bytes.
2619            let cur_offset: usize = (2 - 1) * envelope_size;
2620
2621            // Zero reserved fields.
2622            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2623
2624            // Safety:
2625            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2626            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2627            //   envelope_size bytes, there is always sufficient room.
2628            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2629                self.rate_adjustment_ppm
2630                    .as_ref()
2631                    .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2632                encoder,
2633                offset + cur_offset,
2634                depth,
2635            )?;
2636
2637            _prev_end_offset = cur_offset + envelope_size;
2638
2639            Ok(())
2640        }
2641    }
2642
2643    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClockProperties {
2644        #[inline(always)]
2645        fn new_empty() -> Self {
2646            Self::default()
2647        }
2648
2649        unsafe fn decode(
2650            &mut self,
2651            decoder: &mut fidl::encoding::Decoder<'_, D>,
2652            offset: usize,
2653            mut depth: fidl::encoding::Depth,
2654        ) -> fidl::Result<()> {
2655            decoder.debug_check_bounds::<Self>(offset);
2656            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2657                None => return Err(fidl::Error::NotNullable),
2658                Some(len) => len,
2659            };
2660            // Calling decoder.out_of_line_offset(0) is not allowed.
2661            if len == 0 {
2662                return Ok(());
2663            };
2664            depth.increment()?;
2665            let envelope_size = 8;
2666            let bytes_len = len * envelope_size;
2667            let offset = decoder.out_of_line_offset(bytes_len)?;
2668            // Decode the envelope for each type.
2669            let mut _next_ordinal_to_read = 0;
2670            let mut next_offset = offset;
2671            let end_offset = offset + bytes_len;
2672            _next_ordinal_to_read += 1;
2673            if next_offset >= end_offset {
2674                return Ok(());
2675            }
2676
2677            // Decode unknown envelopes for gaps in ordinals.
2678            while _next_ordinal_to_read < 1 {
2679                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2680                _next_ordinal_to_read += 1;
2681                next_offset += envelope_size;
2682            }
2683
2684            let next_out_of_line = decoder.next_out_of_line();
2685            let handles_before = decoder.remaining_handles();
2686            if let Some((inlined, num_bytes, num_handles)) =
2687                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2688            {
2689                let member_inline_size =
2690                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2691                if inlined != (member_inline_size <= 4) {
2692                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2693                }
2694                let inner_offset;
2695                let mut inner_depth = depth.clone();
2696                if inlined {
2697                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2698                    inner_offset = next_offset;
2699                } else {
2700                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2701                    inner_depth.increment()?;
2702                }
2703                let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(i32, D));
2704                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2706                {
2707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2708                }
2709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2711                }
2712            }
2713
2714            next_offset += envelope_size;
2715            _next_ordinal_to_read += 1;
2716            if next_offset >= end_offset {
2717                return Ok(());
2718            }
2719
2720            // Decode unknown envelopes for gaps in ordinals.
2721            while _next_ordinal_to_read < 2 {
2722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2723                _next_ordinal_to_read += 1;
2724                next_offset += envelope_size;
2725            }
2726
2727            let next_out_of_line = decoder.next_out_of_line();
2728            let handles_before = decoder.remaining_handles();
2729            if let Some((inlined, num_bytes, num_handles)) =
2730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2731            {
2732                let member_inline_size =
2733                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2734                if inlined != (member_inline_size <= 4) {
2735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2736                }
2737                let inner_offset;
2738                let mut inner_depth = depth.clone();
2739                if inlined {
2740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2741                    inner_offset = next_offset;
2742                } else {
2743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2744                    inner_depth.increment()?;
2745                }
2746                let val_ref =
2747                    self.rate_adjustment_ppm.get_or_insert_with(|| fidl::new_empty!(i32, D));
2748                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2750                {
2751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2752                }
2753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2755                }
2756            }
2757
2758            next_offset += envelope_size;
2759
2760            // Decode the remaining unknown envelopes.
2761            while next_offset < end_offset {
2762                _next_ordinal_to_read += 1;
2763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2764                next_offset += envelope_size;
2765            }
2766
2767            Ok(())
2768        }
2769    }
2770
2771    impl Codec {
2772        #[inline(always)]
2773        fn max_ordinal_present(&self) -> u64 {
2774            if let Some(_) = self.plug_properties {
2775                return 3;
2776            }
2777            if let Some(_) = self.dai_interconnect {
2778                return 2;
2779            }
2780            if let Some(_) = self.is_input {
2781                return 1;
2782            }
2783            0
2784        }
2785    }
2786
2787    impl fidl::encoding::ValueTypeMarker for Codec {
2788        type Borrowed<'a> = &'a Self;
2789        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2790            value
2791        }
2792    }
2793
2794    unsafe impl fidl::encoding::TypeMarker for Codec {
2795        type Owned = Self;
2796
2797        #[inline(always)]
2798        fn inline_align(_context: fidl::encoding::Context) -> usize {
2799            8
2800        }
2801
2802        #[inline(always)]
2803        fn inline_size(_context: fidl::encoding::Context) -> usize {
2804            16
2805        }
2806    }
2807
2808    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Codec, D> for &Codec {
2809        unsafe fn encode(
2810            self,
2811            encoder: &mut fidl::encoding::Encoder<'_, D>,
2812            offset: usize,
2813            mut depth: fidl::encoding::Depth,
2814        ) -> fidl::Result<()> {
2815            encoder.debug_check_bounds::<Codec>(offset);
2816            // Vector header
2817            let max_ordinal: u64 = self.max_ordinal_present();
2818            encoder.write_num(max_ordinal, offset);
2819            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2820            // Calling encoder.out_of_line_offset(0) is not allowed.
2821            if max_ordinal == 0 {
2822                return Ok(());
2823            }
2824            depth.increment()?;
2825            let envelope_size = 8;
2826            let bytes_len = max_ordinal as usize * envelope_size;
2827            #[allow(unused_variables)]
2828            let offset = encoder.out_of_line_offset(bytes_len);
2829            let mut _prev_end_offset: usize = 0;
2830            if 1 > max_ordinal {
2831                return Ok(());
2832            }
2833
2834            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2835            // are envelope_size bytes.
2836            let cur_offset: usize = (1 - 1) * envelope_size;
2837
2838            // Zero reserved fields.
2839            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2840
2841            // Safety:
2842            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2843            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2844            //   envelope_size bytes, there is always sufficient room.
2845            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2846                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2847                encoder,
2848                offset + cur_offset,
2849                depth,
2850            )?;
2851
2852            _prev_end_offset = cur_offset + envelope_size;
2853            if 2 > max_ordinal {
2854                return Ok(());
2855            }
2856
2857            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2858            // are envelope_size bytes.
2859            let cur_offset: usize = (2 - 1) * envelope_size;
2860
2861            // Zero reserved fields.
2862            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2863
2864            // Safety:
2865            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2866            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2867            //   envelope_size bytes, there is always sufficient room.
2868            fidl::encoding::encode_in_envelope_optional::<DaiInterconnect, D>(
2869                self.dai_interconnect
2870                    .as_ref()
2871                    .map(<DaiInterconnect as fidl::encoding::ValueTypeMarker>::borrow),
2872                encoder,
2873                offset + cur_offset,
2874                depth,
2875            )?;
2876
2877            _prev_end_offset = cur_offset + envelope_size;
2878            if 3 > max_ordinal {
2879                return Ok(());
2880            }
2881
2882            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2883            // are envelope_size bytes.
2884            let cur_offset: usize = (3 - 1) * envelope_size;
2885
2886            // Zero reserved fields.
2887            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2888
2889            // Safety:
2890            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2891            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2892            //   envelope_size bytes, there is always sufficient room.
2893            fidl::encoding::encode_in_envelope_optional::<PlugProperties, D>(
2894                self.plug_properties
2895                    .as_ref()
2896                    .map(<PlugProperties as fidl::encoding::ValueTypeMarker>::borrow),
2897                encoder,
2898                offset + cur_offset,
2899                depth,
2900            )?;
2901
2902            _prev_end_offset = cur_offset + envelope_size;
2903
2904            Ok(())
2905        }
2906    }
2907
2908    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Codec {
2909        #[inline(always)]
2910        fn new_empty() -> Self {
2911            Self::default()
2912        }
2913
2914        unsafe fn decode(
2915            &mut self,
2916            decoder: &mut fidl::encoding::Decoder<'_, D>,
2917            offset: usize,
2918            mut depth: fidl::encoding::Depth,
2919        ) -> fidl::Result<()> {
2920            decoder.debug_check_bounds::<Self>(offset);
2921            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2922                None => return Err(fidl::Error::NotNullable),
2923                Some(len) => len,
2924            };
2925            // Calling decoder.out_of_line_offset(0) is not allowed.
2926            if len == 0 {
2927                return Ok(());
2928            };
2929            depth.increment()?;
2930            let envelope_size = 8;
2931            let bytes_len = len * envelope_size;
2932            let offset = decoder.out_of_line_offset(bytes_len)?;
2933            // Decode the envelope for each type.
2934            let mut _next_ordinal_to_read = 0;
2935            let mut next_offset = offset;
2936            let end_offset = offset + bytes_len;
2937            _next_ordinal_to_read += 1;
2938            if next_offset >= end_offset {
2939                return Ok(());
2940            }
2941
2942            // Decode unknown envelopes for gaps in ordinals.
2943            while _next_ordinal_to_read < 1 {
2944                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2945                _next_ordinal_to_read += 1;
2946                next_offset += envelope_size;
2947            }
2948
2949            let next_out_of_line = decoder.next_out_of_line();
2950            let handles_before = decoder.remaining_handles();
2951            if let Some((inlined, num_bytes, num_handles)) =
2952                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2953            {
2954                let member_inline_size =
2955                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2956                if inlined != (member_inline_size <= 4) {
2957                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2958                }
2959                let inner_offset;
2960                let mut inner_depth = depth.clone();
2961                if inlined {
2962                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2963                    inner_offset = next_offset;
2964                } else {
2965                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2966                    inner_depth.increment()?;
2967                }
2968                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
2969                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2970                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2971                {
2972                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2973                }
2974                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2975                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2976                }
2977            }
2978
2979            next_offset += envelope_size;
2980            _next_ordinal_to_read += 1;
2981            if next_offset >= end_offset {
2982                return Ok(());
2983            }
2984
2985            // Decode unknown envelopes for gaps in ordinals.
2986            while _next_ordinal_to_read < 2 {
2987                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2988                _next_ordinal_to_read += 1;
2989                next_offset += envelope_size;
2990            }
2991
2992            let next_out_of_line = decoder.next_out_of_line();
2993            let handles_before = decoder.remaining_handles();
2994            if let Some((inlined, num_bytes, num_handles)) =
2995                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2996            {
2997                let member_inline_size =
2998                    <DaiInterconnect as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2999                if inlined != (member_inline_size <= 4) {
3000                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3001                }
3002                let inner_offset;
3003                let mut inner_depth = depth.clone();
3004                if inlined {
3005                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3006                    inner_offset = next_offset;
3007                } else {
3008                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3009                    inner_depth.increment()?;
3010                }
3011                let val_ref = self
3012                    .dai_interconnect
3013                    .get_or_insert_with(|| fidl::new_empty!(DaiInterconnect, D));
3014                fidl::decode!(DaiInterconnect, D, val_ref, decoder, inner_offset, inner_depth)?;
3015                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3016                {
3017                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3018                }
3019                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3020                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3021                }
3022            }
3023
3024            next_offset += envelope_size;
3025            _next_ordinal_to_read += 1;
3026            if next_offset >= end_offset {
3027                return Ok(());
3028            }
3029
3030            // Decode unknown envelopes for gaps in ordinals.
3031            while _next_ordinal_to_read < 3 {
3032                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3033                _next_ordinal_to_read += 1;
3034                next_offset += envelope_size;
3035            }
3036
3037            let next_out_of_line = decoder.next_out_of_line();
3038            let handles_before = decoder.remaining_handles();
3039            if let Some((inlined, num_bytes, num_handles)) =
3040                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3041            {
3042                let member_inline_size =
3043                    <PlugProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3044                if inlined != (member_inline_size <= 4) {
3045                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3046                }
3047                let inner_offset;
3048                let mut inner_depth = depth.clone();
3049                if inlined {
3050                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3051                    inner_offset = next_offset;
3052                } else {
3053                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3054                    inner_depth.increment()?;
3055                }
3056                let val_ref =
3057                    self.plug_properties.get_or_insert_with(|| fidl::new_empty!(PlugProperties, D));
3058                fidl::decode!(PlugProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3059                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3060                {
3061                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3062                }
3063                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3064                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3065                }
3066            }
3067
3068            next_offset += envelope_size;
3069
3070            // Decode the remaining unknown envelopes.
3071            while next_offset < end_offset {
3072                _next_ordinal_to_read += 1;
3073                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3074                next_offset += envelope_size;
3075            }
3076
3077            Ok(())
3078        }
3079    }
3080
3081    impl Composite {
3082        #[inline(always)]
3083        fn max_ordinal_present(&self) -> u64 {
3084            if let Some(_) = self.topologies {
3085                return 4;
3086            }
3087            if let Some(_) = self.clock_properties {
3088                return 3;
3089            }
3090            if let Some(_) = self.dai_interconnects {
3091                return 2;
3092            }
3093            if let Some(_) = self.ring_buffers {
3094                return 1;
3095            }
3096            0
3097        }
3098    }
3099
3100    impl fidl::encoding::ValueTypeMarker for Composite {
3101        type Borrowed<'a> = &'a Self;
3102        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3103            value
3104        }
3105    }
3106
3107    unsafe impl fidl::encoding::TypeMarker for Composite {
3108        type Owned = Self;
3109
3110        #[inline(always)]
3111        fn inline_align(_context: fidl::encoding::Context) -> usize {
3112            8
3113        }
3114
3115        #[inline(always)]
3116        fn inline_size(_context: fidl::encoding::Context) -> usize {
3117            16
3118        }
3119    }
3120
3121    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Composite, D>
3122        for &Composite
3123    {
3124        unsafe fn encode(
3125            self,
3126            encoder: &mut fidl::encoding::Encoder<'_, D>,
3127            offset: usize,
3128            mut depth: fidl::encoding::Depth,
3129        ) -> fidl::Result<()> {
3130            encoder.debug_check_bounds::<Composite>(offset);
3131            // Vector header
3132            let max_ordinal: u64 = self.max_ordinal_present();
3133            encoder.write_num(max_ordinal, offset);
3134            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3135            // Calling encoder.out_of_line_offset(0) is not allowed.
3136            if max_ordinal == 0 {
3137                return Ok(());
3138            }
3139            depth.increment()?;
3140            let envelope_size = 8;
3141            let bytes_len = max_ordinal as usize * envelope_size;
3142            #[allow(unused_variables)]
3143            let offset = encoder.out_of_line_offset(bytes_len);
3144            let mut _prev_end_offset: usize = 0;
3145            if 1 > max_ordinal {
3146                return Ok(());
3147            }
3148
3149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3150            // are envelope_size bytes.
3151            let cur_offset: usize = (1 - 1) * envelope_size;
3152
3153            // Zero reserved fields.
3154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3155
3156            // Safety:
3157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3159            //   envelope_size bytes, there is always sufficient room.
3160            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CompositeRingBuffer, 64>, D>(
3161            self.ring_buffers.as_ref().map(<fidl::encoding::Vector<CompositeRingBuffer, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3162            encoder, offset + cur_offset, depth
3163        )?;
3164
3165            _prev_end_offset = cur_offset + envelope_size;
3166            if 2 > max_ordinal {
3167                return Ok(());
3168            }
3169
3170            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3171            // are envelope_size bytes.
3172            let cur_offset: usize = (2 - 1) * envelope_size;
3173
3174            // Zero reserved fields.
3175            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3176
3177            // Safety:
3178            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3179            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3180            //   envelope_size bytes, there is always sufficient room.
3181            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CompositeDaiInterconnect, 64>, D>(
3182            self.dai_interconnects.as_ref().map(<fidl::encoding::Vector<CompositeDaiInterconnect, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3183            encoder, offset + cur_offset, depth
3184        )?;
3185
3186            _prev_end_offset = cur_offset + envelope_size;
3187            if 3 > max_ordinal {
3188                return Ok(());
3189            }
3190
3191            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3192            // are envelope_size bytes.
3193            let cur_offset: usize = (3 - 1) * envelope_size;
3194
3195            // Zero reserved fields.
3196            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3197
3198            // Safety:
3199            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3200            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3201            //   envelope_size bytes, there is always sufficient room.
3202            fidl::encoding::encode_in_envelope_optional::<ClockProperties, D>(
3203                self.clock_properties
3204                    .as_ref()
3205                    .map(<ClockProperties as fidl::encoding::ValueTypeMarker>::borrow),
3206                encoder,
3207                offset + cur_offset,
3208                depth,
3209            )?;
3210
3211            _prev_end_offset = cur_offset + envelope_size;
3212            if 4 > max_ordinal {
3213                return Ok(());
3214            }
3215
3216            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3217            // are envelope_size bytes.
3218            let cur_offset: usize = (4 - 1) * envelope_size;
3219
3220            // Zero reserved fields.
3221            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3222
3223            // Safety:
3224            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3225            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3226            //   envelope_size bytes, there is always sufficient room.
3227            fidl::encoding::encode_in_envelope_optional::<
3228                fidl::encoding::Vector<
3229                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
3230                    64,
3231                >,
3232                D,
3233            >(
3234                self.topologies.as_ref().map(
3235                    <fidl::encoding::Vector<
3236                        fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
3237                        64,
3238                    > as fidl::encoding::ValueTypeMarker>::borrow,
3239                ),
3240                encoder,
3241                offset + cur_offset,
3242                depth,
3243            )?;
3244
3245            _prev_end_offset = cur_offset + envelope_size;
3246
3247            Ok(())
3248        }
3249    }
3250
3251    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Composite {
3252        #[inline(always)]
3253        fn new_empty() -> Self {
3254            Self::default()
3255        }
3256
3257        unsafe fn decode(
3258            &mut self,
3259            decoder: &mut fidl::encoding::Decoder<'_, D>,
3260            offset: usize,
3261            mut depth: fidl::encoding::Depth,
3262        ) -> fidl::Result<()> {
3263            decoder.debug_check_bounds::<Self>(offset);
3264            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3265                None => return Err(fidl::Error::NotNullable),
3266                Some(len) => len,
3267            };
3268            // Calling decoder.out_of_line_offset(0) is not allowed.
3269            if len == 0 {
3270                return Ok(());
3271            };
3272            depth.increment()?;
3273            let envelope_size = 8;
3274            let bytes_len = len * envelope_size;
3275            let offset = decoder.out_of_line_offset(bytes_len)?;
3276            // Decode the envelope for each type.
3277            let mut _next_ordinal_to_read = 0;
3278            let mut next_offset = offset;
3279            let end_offset = offset + bytes_len;
3280            _next_ordinal_to_read += 1;
3281            if next_offset >= end_offset {
3282                return Ok(());
3283            }
3284
3285            // Decode unknown envelopes for gaps in ordinals.
3286            while _next_ordinal_to_read < 1 {
3287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3288                _next_ordinal_to_read += 1;
3289                next_offset += envelope_size;
3290            }
3291
3292            let next_out_of_line = decoder.next_out_of_line();
3293            let handles_before = decoder.remaining_handles();
3294            if let Some((inlined, num_bytes, num_handles)) =
3295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3296            {
3297                let member_inline_size = <fidl::encoding::Vector<CompositeRingBuffer, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3298                if inlined != (member_inline_size <= 4) {
3299                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3300                }
3301                let inner_offset;
3302                let mut inner_depth = depth.clone();
3303                if inlined {
3304                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3305                    inner_offset = next_offset;
3306                } else {
3307                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3308                    inner_depth.increment()?;
3309                }
3310                let val_ref = self.ring_buffers.get_or_insert_with(
3311                    || fidl::new_empty!(fidl::encoding::Vector<CompositeRingBuffer, 64>, D),
3312                );
3313                fidl::decode!(fidl::encoding::Vector<CompositeRingBuffer, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3314                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3315                {
3316                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3317                }
3318                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3319                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3320                }
3321            }
3322
3323            next_offset += envelope_size;
3324            _next_ordinal_to_read += 1;
3325            if next_offset >= end_offset {
3326                return Ok(());
3327            }
3328
3329            // Decode unknown envelopes for gaps in ordinals.
3330            while _next_ordinal_to_read < 2 {
3331                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3332                _next_ordinal_to_read += 1;
3333                next_offset += envelope_size;
3334            }
3335
3336            let next_out_of_line = decoder.next_out_of_line();
3337            let handles_before = decoder.remaining_handles();
3338            if let Some((inlined, num_bytes, num_handles)) =
3339                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3340            {
3341                let member_inline_size = <fidl::encoding::Vector<CompositeDaiInterconnect, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3342                if inlined != (member_inline_size <= 4) {
3343                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3344                }
3345                let inner_offset;
3346                let mut inner_depth = depth.clone();
3347                if inlined {
3348                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3349                    inner_offset = next_offset;
3350                } else {
3351                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3352                    inner_depth.increment()?;
3353                }
3354                let val_ref = self.dai_interconnects.get_or_insert_with(
3355                    || fidl::new_empty!(fidl::encoding::Vector<CompositeDaiInterconnect, 64>, D),
3356                );
3357                fidl::decode!(fidl::encoding::Vector<CompositeDaiInterconnect, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3358                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3359                {
3360                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3361                }
3362                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3363                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3364                }
3365            }
3366
3367            next_offset += envelope_size;
3368            _next_ordinal_to_read += 1;
3369            if next_offset >= end_offset {
3370                return Ok(());
3371            }
3372
3373            // Decode unknown envelopes for gaps in ordinals.
3374            while _next_ordinal_to_read < 3 {
3375                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3376                _next_ordinal_to_read += 1;
3377                next_offset += envelope_size;
3378            }
3379
3380            let next_out_of_line = decoder.next_out_of_line();
3381            let handles_before = decoder.remaining_handles();
3382            if let Some((inlined, num_bytes, num_handles)) =
3383                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3384            {
3385                let member_inline_size =
3386                    <ClockProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3387                if inlined != (member_inline_size <= 4) {
3388                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3389                }
3390                let inner_offset;
3391                let mut inner_depth = depth.clone();
3392                if inlined {
3393                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3394                    inner_offset = next_offset;
3395                } else {
3396                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3397                    inner_depth.increment()?;
3398                }
3399                let val_ref = self
3400                    .clock_properties
3401                    .get_or_insert_with(|| fidl::new_empty!(ClockProperties, D));
3402                fidl::decode!(ClockProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3403                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3404                {
3405                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3406                }
3407                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3408                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3409                }
3410            }
3411
3412            next_offset += envelope_size;
3413            _next_ordinal_to_read += 1;
3414            if next_offset >= end_offset {
3415                return Ok(());
3416            }
3417
3418            // Decode unknown envelopes for gaps in ordinals.
3419            while _next_ordinal_to_read < 4 {
3420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3421                _next_ordinal_to_read += 1;
3422                next_offset += envelope_size;
3423            }
3424
3425            let next_out_of_line = decoder.next_out_of_line();
3426            let handles_before = decoder.remaining_handles();
3427            if let Some((inlined, num_bytes, num_handles)) =
3428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3429            {
3430                let member_inline_size = <fidl::encoding::Vector<
3431                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
3432                    64,
3433                > as fidl::encoding::TypeMarker>::inline_size(
3434                    decoder.context
3435                );
3436                if inlined != (member_inline_size <= 4) {
3437                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3438                }
3439                let inner_offset;
3440                let mut inner_depth = depth.clone();
3441                if inlined {
3442                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3443                    inner_offset = next_offset;
3444                } else {
3445                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3446                    inner_depth.increment()?;
3447                }
3448                let val_ref =
3449                self.topologies.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D));
3450                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3451                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3452                {
3453                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3454                }
3455                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3456                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3457                }
3458            }
3459
3460            next_offset += envelope_size;
3461
3462            // Decode the remaining unknown envelopes.
3463            while next_offset < end_offset {
3464                _next_ordinal_to_read += 1;
3465                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3466                next_offset += envelope_size;
3467            }
3468
3469            Ok(())
3470        }
3471    }
3472
3473    impl CompositeDaiInterconnect {
3474        #[inline(always)]
3475        fn max_ordinal_present(&self) -> u64 {
3476            if let Some(_) = self.dai_interconnect {
3477                return 2;
3478            }
3479            if let Some(_) = self.id {
3480                return 1;
3481            }
3482            0
3483        }
3484    }
3485
3486    impl fidl::encoding::ValueTypeMarker for CompositeDaiInterconnect {
3487        type Borrowed<'a> = &'a Self;
3488        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3489            value
3490        }
3491    }
3492
3493    unsafe impl fidl::encoding::TypeMarker for CompositeDaiInterconnect {
3494        type Owned = Self;
3495
3496        #[inline(always)]
3497        fn inline_align(_context: fidl::encoding::Context) -> usize {
3498            8
3499        }
3500
3501        #[inline(always)]
3502        fn inline_size(_context: fidl::encoding::Context) -> usize {
3503            16
3504        }
3505    }
3506
3507    unsafe impl<D: fidl::encoding::ResourceDialect>
3508        fidl::encoding::Encode<CompositeDaiInterconnect, D> for &CompositeDaiInterconnect
3509    {
3510        unsafe fn encode(
3511            self,
3512            encoder: &mut fidl::encoding::Encoder<'_, D>,
3513            offset: usize,
3514            mut depth: fidl::encoding::Depth,
3515        ) -> fidl::Result<()> {
3516            encoder.debug_check_bounds::<CompositeDaiInterconnect>(offset);
3517            // Vector header
3518            let max_ordinal: u64 = self.max_ordinal_present();
3519            encoder.write_num(max_ordinal, offset);
3520            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3521            // Calling encoder.out_of_line_offset(0) is not allowed.
3522            if max_ordinal == 0 {
3523                return Ok(());
3524            }
3525            depth.increment()?;
3526            let envelope_size = 8;
3527            let bytes_len = max_ordinal as usize * envelope_size;
3528            #[allow(unused_variables)]
3529            let offset = encoder.out_of_line_offset(bytes_len);
3530            let mut _prev_end_offset: usize = 0;
3531            if 1 > max_ordinal {
3532                return Ok(());
3533            }
3534
3535            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3536            // are envelope_size bytes.
3537            let cur_offset: usize = (1 - 1) * envelope_size;
3538
3539            // Zero reserved fields.
3540            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3541
3542            // Safety:
3543            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3544            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3545            //   envelope_size bytes, there is always sufficient room.
3546            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3547                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3548                encoder,
3549                offset + cur_offset,
3550                depth,
3551            )?;
3552
3553            _prev_end_offset = cur_offset + envelope_size;
3554            if 2 > max_ordinal {
3555                return Ok(());
3556            }
3557
3558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3559            // are envelope_size bytes.
3560            let cur_offset: usize = (2 - 1) * envelope_size;
3561
3562            // Zero reserved fields.
3563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3564
3565            // Safety:
3566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3568            //   envelope_size bytes, there is always sufficient room.
3569            fidl::encoding::encode_in_envelope_optional::<DaiInterconnect, D>(
3570                self.dai_interconnect
3571                    .as_ref()
3572                    .map(<DaiInterconnect as fidl::encoding::ValueTypeMarker>::borrow),
3573                encoder,
3574                offset + cur_offset,
3575                depth,
3576            )?;
3577
3578            _prev_end_offset = cur_offset + envelope_size;
3579
3580            Ok(())
3581        }
3582    }
3583
3584    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3585        for CompositeDaiInterconnect
3586    {
3587        #[inline(always)]
3588        fn new_empty() -> Self {
3589            Self::default()
3590        }
3591
3592        unsafe fn decode(
3593            &mut self,
3594            decoder: &mut fidl::encoding::Decoder<'_, D>,
3595            offset: usize,
3596            mut depth: fidl::encoding::Depth,
3597        ) -> fidl::Result<()> {
3598            decoder.debug_check_bounds::<Self>(offset);
3599            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3600                None => return Err(fidl::Error::NotNullable),
3601                Some(len) => len,
3602            };
3603            // Calling decoder.out_of_line_offset(0) is not allowed.
3604            if len == 0 {
3605                return Ok(());
3606            };
3607            depth.increment()?;
3608            let envelope_size = 8;
3609            let bytes_len = len * envelope_size;
3610            let offset = decoder.out_of_line_offset(bytes_len)?;
3611            // Decode the envelope for each type.
3612            let mut _next_ordinal_to_read = 0;
3613            let mut next_offset = offset;
3614            let end_offset = offset + bytes_len;
3615            _next_ordinal_to_read += 1;
3616            if next_offset >= end_offset {
3617                return Ok(());
3618            }
3619
3620            // Decode unknown envelopes for gaps in ordinals.
3621            while _next_ordinal_to_read < 1 {
3622                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3623                _next_ordinal_to_read += 1;
3624                next_offset += envelope_size;
3625            }
3626
3627            let next_out_of_line = decoder.next_out_of_line();
3628            let handles_before = decoder.remaining_handles();
3629            if let Some((inlined, num_bytes, num_handles)) =
3630                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3631            {
3632                let member_inline_size =
3633                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3634                if inlined != (member_inline_size <= 4) {
3635                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3636                }
3637                let inner_offset;
3638                let mut inner_depth = depth.clone();
3639                if inlined {
3640                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3641                    inner_offset = next_offset;
3642                } else {
3643                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3644                    inner_depth.increment()?;
3645                }
3646                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3647                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3648                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3649                {
3650                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3651                }
3652                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3653                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3654                }
3655            }
3656
3657            next_offset += envelope_size;
3658            _next_ordinal_to_read += 1;
3659            if next_offset >= end_offset {
3660                return Ok(());
3661            }
3662
3663            // Decode unknown envelopes for gaps in ordinals.
3664            while _next_ordinal_to_read < 2 {
3665                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3666                _next_ordinal_to_read += 1;
3667                next_offset += envelope_size;
3668            }
3669
3670            let next_out_of_line = decoder.next_out_of_line();
3671            let handles_before = decoder.remaining_handles();
3672            if let Some((inlined, num_bytes, num_handles)) =
3673                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3674            {
3675                let member_inline_size =
3676                    <DaiInterconnect as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3677                if inlined != (member_inline_size <= 4) {
3678                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3679                }
3680                let inner_offset;
3681                let mut inner_depth = depth.clone();
3682                if inlined {
3683                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3684                    inner_offset = next_offset;
3685                } else {
3686                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3687                    inner_depth.increment()?;
3688                }
3689                let val_ref = self
3690                    .dai_interconnect
3691                    .get_or_insert_with(|| fidl::new_empty!(DaiInterconnect, D));
3692                fidl::decode!(DaiInterconnect, D, val_ref, decoder, inner_offset, inner_depth)?;
3693                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3694                {
3695                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3696                }
3697                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3698                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3699                }
3700            }
3701
3702            next_offset += envelope_size;
3703
3704            // Decode the remaining unknown envelopes.
3705            while next_offset < end_offset {
3706                _next_ordinal_to_read += 1;
3707                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3708                next_offset += envelope_size;
3709            }
3710
3711            Ok(())
3712        }
3713    }
3714
3715    impl CompositeRingBuffer {
3716        #[inline(always)]
3717        fn max_ordinal_present(&self) -> u64 {
3718            if let Some(_) = self.ring_buffer {
3719                return 2;
3720            }
3721            if let Some(_) = self.id {
3722                return 1;
3723            }
3724            0
3725        }
3726    }
3727
3728    impl fidl::encoding::ValueTypeMarker for CompositeRingBuffer {
3729        type Borrowed<'a> = &'a Self;
3730        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3731            value
3732        }
3733    }
3734
3735    unsafe impl fidl::encoding::TypeMarker for CompositeRingBuffer {
3736        type Owned = Self;
3737
3738        #[inline(always)]
3739        fn inline_align(_context: fidl::encoding::Context) -> usize {
3740            8
3741        }
3742
3743        #[inline(always)]
3744        fn inline_size(_context: fidl::encoding::Context) -> usize {
3745            16
3746        }
3747    }
3748
3749    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeRingBuffer, D>
3750        for &CompositeRingBuffer
3751    {
3752        unsafe fn encode(
3753            self,
3754            encoder: &mut fidl::encoding::Encoder<'_, D>,
3755            offset: usize,
3756            mut depth: fidl::encoding::Depth,
3757        ) -> fidl::Result<()> {
3758            encoder.debug_check_bounds::<CompositeRingBuffer>(offset);
3759            // Vector header
3760            let max_ordinal: u64 = self.max_ordinal_present();
3761            encoder.write_num(max_ordinal, offset);
3762            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3763            // Calling encoder.out_of_line_offset(0) is not allowed.
3764            if max_ordinal == 0 {
3765                return Ok(());
3766            }
3767            depth.increment()?;
3768            let envelope_size = 8;
3769            let bytes_len = max_ordinal as usize * envelope_size;
3770            #[allow(unused_variables)]
3771            let offset = encoder.out_of_line_offset(bytes_len);
3772            let mut _prev_end_offset: usize = 0;
3773            if 1 > max_ordinal {
3774                return Ok(());
3775            }
3776
3777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3778            // are envelope_size bytes.
3779            let cur_offset: usize = (1 - 1) * envelope_size;
3780
3781            // Zero reserved fields.
3782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3783
3784            // Safety:
3785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3787            //   envelope_size bytes, there is always sufficient room.
3788            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3789                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3790                encoder,
3791                offset + cur_offset,
3792                depth,
3793            )?;
3794
3795            _prev_end_offset = cur_offset + envelope_size;
3796            if 2 > max_ordinal {
3797                return Ok(());
3798            }
3799
3800            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3801            // are envelope_size bytes.
3802            let cur_offset: usize = (2 - 1) * envelope_size;
3803
3804            // Zero reserved fields.
3805            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3806
3807            // Safety:
3808            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3809            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3810            //   envelope_size bytes, there is always sufficient room.
3811            fidl::encoding::encode_in_envelope_optional::<RingBuffer, D>(
3812                self.ring_buffer
3813                    .as_ref()
3814                    .map(<RingBuffer as fidl::encoding::ValueTypeMarker>::borrow),
3815                encoder,
3816                offset + cur_offset,
3817                depth,
3818            )?;
3819
3820            _prev_end_offset = cur_offset + envelope_size;
3821
3822            Ok(())
3823        }
3824    }
3825
3826    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeRingBuffer {
3827        #[inline(always)]
3828        fn new_empty() -> Self {
3829            Self::default()
3830        }
3831
3832        unsafe fn decode(
3833            &mut self,
3834            decoder: &mut fidl::encoding::Decoder<'_, D>,
3835            offset: usize,
3836            mut depth: fidl::encoding::Depth,
3837        ) -> fidl::Result<()> {
3838            decoder.debug_check_bounds::<Self>(offset);
3839            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3840                None => return Err(fidl::Error::NotNullable),
3841                Some(len) => len,
3842            };
3843            // Calling decoder.out_of_line_offset(0) is not allowed.
3844            if len == 0 {
3845                return Ok(());
3846            };
3847            depth.increment()?;
3848            let envelope_size = 8;
3849            let bytes_len = len * envelope_size;
3850            let offset = decoder.out_of_line_offset(bytes_len)?;
3851            // Decode the envelope for each type.
3852            let mut _next_ordinal_to_read = 0;
3853            let mut next_offset = offset;
3854            let end_offset = offset + bytes_len;
3855            _next_ordinal_to_read += 1;
3856            if next_offset >= end_offset {
3857                return Ok(());
3858            }
3859
3860            // Decode unknown envelopes for gaps in ordinals.
3861            while _next_ordinal_to_read < 1 {
3862                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3863                _next_ordinal_to_read += 1;
3864                next_offset += envelope_size;
3865            }
3866
3867            let next_out_of_line = decoder.next_out_of_line();
3868            let handles_before = decoder.remaining_handles();
3869            if let Some((inlined, num_bytes, num_handles)) =
3870                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3871            {
3872                let member_inline_size =
3873                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3874                if inlined != (member_inline_size <= 4) {
3875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3876                }
3877                let inner_offset;
3878                let mut inner_depth = depth.clone();
3879                if inlined {
3880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3881                    inner_offset = next_offset;
3882                } else {
3883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3884                    inner_depth.increment()?;
3885                }
3886                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3887                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3888                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3889                {
3890                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3891                }
3892                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3893                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3894                }
3895            }
3896
3897            next_offset += envelope_size;
3898            _next_ordinal_to_read += 1;
3899            if next_offset >= end_offset {
3900                return Ok(());
3901            }
3902
3903            // Decode unknown envelopes for gaps in ordinals.
3904            while _next_ordinal_to_read < 2 {
3905                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3906                _next_ordinal_to_read += 1;
3907                next_offset += envelope_size;
3908            }
3909
3910            let next_out_of_line = decoder.next_out_of_line();
3911            let handles_before = decoder.remaining_handles();
3912            if let Some((inlined, num_bytes, num_handles)) =
3913                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3914            {
3915                let member_inline_size =
3916                    <RingBuffer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3917                if inlined != (member_inline_size <= 4) {
3918                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3919                }
3920                let inner_offset;
3921                let mut inner_depth = depth.clone();
3922                if inlined {
3923                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3924                    inner_offset = next_offset;
3925                } else {
3926                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3927                    inner_depth.increment()?;
3928                }
3929                let val_ref =
3930                    self.ring_buffer.get_or_insert_with(|| fidl::new_empty!(RingBuffer, D));
3931                fidl::decode!(RingBuffer, D, val_ref, decoder, inner_offset, inner_depth)?;
3932                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3933                {
3934                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3935                }
3936                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3937                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3938                }
3939            }
3940
3941            next_offset += envelope_size;
3942
3943            // Decode the remaining unknown envelopes.
3944            while next_offset < end_offset {
3945                _next_ordinal_to_read += 1;
3946                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3947                next_offset += envelope_size;
3948            }
3949
3950            Ok(())
3951        }
3952    }
3953
3954    impl Configuration {
3955        #[inline(always)]
3956        fn max_ordinal_present(&self) -> u64 {
3957            if let Some(_) = self.device_specific {
3958                return 5;
3959            }
3960            if let Some(_) = self.unique_id {
3961                return 4;
3962            }
3963            if let Some(_) = self.product_name {
3964                return 3;
3965            }
3966            if let Some(_) = self.manufacturer_name {
3967                return 2;
3968            }
3969            if let Some(_) = self.device_name {
3970                return 1;
3971            }
3972            0
3973        }
3974    }
3975
3976    impl fidl::encoding::ValueTypeMarker for Configuration {
3977        type Borrowed<'a> = &'a Self;
3978        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3979            value
3980        }
3981    }
3982
3983    unsafe impl fidl::encoding::TypeMarker for Configuration {
3984        type Owned = Self;
3985
3986        #[inline(always)]
3987        fn inline_align(_context: fidl::encoding::Context) -> usize {
3988            8
3989        }
3990
3991        #[inline(always)]
3992        fn inline_size(_context: fidl::encoding::Context) -> usize {
3993            16
3994        }
3995    }
3996
3997    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
3998        for &Configuration
3999    {
4000        unsafe fn encode(
4001            self,
4002            encoder: &mut fidl::encoding::Encoder<'_, D>,
4003            offset: usize,
4004            mut depth: fidl::encoding::Depth,
4005        ) -> fidl::Result<()> {
4006            encoder.debug_check_bounds::<Configuration>(offset);
4007            // Vector header
4008            let max_ordinal: u64 = self.max_ordinal_present();
4009            encoder.write_num(max_ordinal, offset);
4010            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4011            // Calling encoder.out_of_line_offset(0) is not allowed.
4012            if max_ordinal == 0 {
4013                return Ok(());
4014            }
4015            depth.increment()?;
4016            let envelope_size = 8;
4017            let bytes_len = max_ordinal as usize * envelope_size;
4018            #[allow(unused_variables)]
4019            let offset = encoder.out_of_line_offset(bytes_len);
4020            let mut _prev_end_offset: usize = 0;
4021            if 1 > max_ordinal {
4022                return Ok(());
4023            }
4024
4025            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4026            // are envelope_size bytes.
4027            let cur_offset: usize = (1 - 1) * envelope_size;
4028
4029            // Zero reserved fields.
4030            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4031
4032            // Safety:
4033            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4034            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4035            //   envelope_size bytes, there is always sufficient room.
4036            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
4037                self.device_name.as_ref().map(
4038                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
4039                ),
4040                encoder,
4041                offset + cur_offset,
4042                depth,
4043            )?;
4044
4045            _prev_end_offset = cur_offset + envelope_size;
4046            if 2 > max_ordinal {
4047                return Ok(());
4048            }
4049
4050            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4051            // are envelope_size bytes.
4052            let cur_offset: usize = (2 - 1) * envelope_size;
4053
4054            // Zero reserved fields.
4055            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4056
4057            // Safety:
4058            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4059            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4060            //   envelope_size bytes, there is always sufficient room.
4061            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
4062                self.manufacturer_name.as_ref().map(
4063                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
4064                ),
4065                encoder,
4066                offset + cur_offset,
4067                depth,
4068            )?;
4069
4070            _prev_end_offset = cur_offset + envelope_size;
4071            if 3 > max_ordinal {
4072                return Ok(());
4073            }
4074
4075            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4076            // are envelope_size bytes.
4077            let cur_offset: usize = (3 - 1) * envelope_size;
4078
4079            // Zero reserved fields.
4080            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4081
4082            // Safety:
4083            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4084            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4085            //   envelope_size bytes, there is always sufficient room.
4086            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
4087                self.product_name.as_ref().map(
4088                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
4089                ),
4090                encoder,
4091                offset + cur_offset,
4092                depth,
4093            )?;
4094
4095            _prev_end_offset = cur_offset + envelope_size;
4096            if 4 > max_ordinal {
4097                return Ok(());
4098            }
4099
4100            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4101            // are envelope_size bytes.
4102            let cur_offset: usize = (4 - 1) * envelope_size;
4103
4104            // Zero reserved fields.
4105            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4106
4107            // Safety:
4108            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4109            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4110            //   envelope_size bytes, there is always sufficient room.
4111            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
4112                self.unique_id.as_ref().map(
4113                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
4114                ),
4115                encoder,
4116                offset + cur_offset,
4117                depth,
4118            )?;
4119
4120            _prev_end_offset = cur_offset + envelope_size;
4121            if 5 > max_ordinal {
4122                return Ok(());
4123            }
4124
4125            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4126            // are envelope_size bytes.
4127            let cur_offset: usize = (5 - 1) * envelope_size;
4128
4129            // Zero reserved fields.
4130            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4131
4132            // Safety:
4133            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4134            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4135            //   envelope_size bytes, there is always sufficient room.
4136            fidl::encoding::encode_in_envelope_optional::<DeviceSpecific, D>(
4137                self.device_specific
4138                    .as_ref()
4139                    .map(<DeviceSpecific as fidl::encoding::ValueTypeMarker>::borrow),
4140                encoder,
4141                offset + cur_offset,
4142                depth,
4143            )?;
4144
4145            _prev_end_offset = cur_offset + envelope_size;
4146
4147            Ok(())
4148        }
4149    }
4150
4151    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
4152        #[inline(always)]
4153        fn new_empty() -> Self {
4154            Self::default()
4155        }
4156
4157        unsafe fn decode(
4158            &mut self,
4159            decoder: &mut fidl::encoding::Decoder<'_, D>,
4160            offset: usize,
4161            mut depth: fidl::encoding::Depth,
4162        ) -> fidl::Result<()> {
4163            decoder.debug_check_bounds::<Self>(offset);
4164            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4165                None => return Err(fidl::Error::NotNullable),
4166                Some(len) => len,
4167            };
4168            // Calling decoder.out_of_line_offset(0) is not allowed.
4169            if len == 0 {
4170                return Ok(());
4171            };
4172            depth.increment()?;
4173            let envelope_size = 8;
4174            let bytes_len = len * envelope_size;
4175            let offset = decoder.out_of_line_offset(bytes_len)?;
4176            // Decode the envelope for each type.
4177            let mut _next_ordinal_to_read = 0;
4178            let mut next_offset = offset;
4179            let end_offset = offset + bytes_len;
4180            _next_ordinal_to_read += 1;
4181            if next_offset >= end_offset {
4182                return Ok(());
4183            }
4184
4185            // Decode unknown envelopes for gaps in ordinals.
4186            while _next_ordinal_to_read < 1 {
4187                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4188                _next_ordinal_to_read += 1;
4189                next_offset += envelope_size;
4190            }
4191
4192            let next_out_of_line = decoder.next_out_of_line();
4193            let handles_before = decoder.remaining_handles();
4194            if let Some((inlined, num_bytes, num_handles)) =
4195                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4196            {
4197                let member_inline_size =
4198                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
4199                        decoder.context,
4200                    );
4201                if inlined != (member_inline_size <= 4) {
4202                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4203                }
4204                let inner_offset;
4205                let mut inner_depth = depth.clone();
4206                if inlined {
4207                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4208                    inner_offset = next_offset;
4209                } else {
4210                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4211                    inner_depth.increment()?;
4212                }
4213                let val_ref = self
4214                    .device_name
4215                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
4216                fidl::decode!(
4217                    fidl::encoding::BoundedString<256>,
4218                    D,
4219                    val_ref,
4220                    decoder,
4221                    inner_offset,
4222                    inner_depth
4223                )?;
4224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4225                {
4226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4227                }
4228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4230                }
4231            }
4232
4233            next_offset += envelope_size;
4234            _next_ordinal_to_read += 1;
4235            if next_offset >= end_offset {
4236                return Ok(());
4237            }
4238
4239            // Decode unknown envelopes for gaps in ordinals.
4240            while _next_ordinal_to_read < 2 {
4241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4242                _next_ordinal_to_read += 1;
4243                next_offset += envelope_size;
4244            }
4245
4246            let next_out_of_line = decoder.next_out_of_line();
4247            let handles_before = decoder.remaining_handles();
4248            if let Some((inlined, num_bytes, num_handles)) =
4249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4250            {
4251                let member_inline_size =
4252                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
4253                        decoder.context,
4254                    );
4255                if inlined != (member_inline_size <= 4) {
4256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4257                }
4258                let inner_offset;
4259                let mut inner_depth = depth.clone();
4260                if inlined {
4261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4262                    inner_offset = next_offset;
4263                } else {
4264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4265                    inner_depth.increment()?;
4266                }
4267                let val_ref = self
4268                    .manufacturer_name
4269                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
4270                fidl::decode!(
4271                    fidl::encoding::BoundedString<256>,
4272                    D,
4273                    val_ref,
4274                    decoder,
4275                    inner_offset,
4276                    inner_depth
4277                )?;
4278                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4279                {
4280                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4281                }
4282                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4283                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4284                }
4285            }
4286
4287            next_offset += envelope_size;
4288            _next_ordinal_to_read += 1;
4289            if next_offset >= end_offset {
4290                return Ok(());
4291            }
4292
4293            // Decode unknown envelopes for gaps in ordinals.
4294            while _next_ordinal_to_read < 3 {
4295                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4296                _next_ordinal_to_read += 1;
4297                next_offset += envelope_size;
4298            }
4299
4300            let next_out_of_line = decoder.next_out_of_line();
4301            let handles_before = decoder.remaining_handles();
4302            if let Some((inlined, num_bytes, num_handles)) =
4303                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4304            {
4305                let member_inline_size =
4306                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
4307                        decoder.context,
4308                    );
4309                if inlined != (member_inline_size <= 4) {
4310                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4311                }
4312                let inner_offset;
4313                let mut inner_depth = depth.clone();
4314                if inlined {
4315                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4316                    inner_offset = next_offset;
4317                } else {
4318                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4319                    inner_depth.increment()?;
4320                }
4321                let val_ref = self
4322                    .product_name
4323                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
4324                fidl::decode!(
4325                    fidl::encoding::BoundedString<256>,
4326                    D,
4327                    val_ref,
4328                    decoder,
4329                    inner_offset,
4330                    inner_depth
4331                )?;
4332                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4333                {
4334                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4335                }
4336                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4337                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4338                }
4339            }
4340
4341            next_offset += envelope_size;
4342            _next_ordinal_to_read += 1;
4343            if next_offset >= end_offset {
4344                return Ok(());
4345            }
4346
4347            // Decode unknown envelopes for gaps in ordinals.
4348            while _next_ordinal_to_read < 4 {
4349                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4350                _next_ordinal_to_read += 1;
4351                next_offset += envelope_size;
4352            }
4353
4354            let next_out_of_line = decoder.next_out_of_line();
4355            let handles_before = decoder.remaining_handles();
4356            if let Some((inlined, num_bytes, num_handles)) =
4357                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4358            {
4359                let member_inline_size =
4360                    <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
4361                        decoder.context,
4362                    );
4363                if inlined != (member_inline_size <= 4) {
4364                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4365                }
4366                let inner_offset;
4367                let mut inner_depth = depth.clone();
4368                if inlined {
4369                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4370                    inner_offset = next_offset;
4371                } else {
4372                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4373                    inner_depth.increment()?;
4374                }
4375                let val_ref = self
4376                    .unique_id
4377                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
4378                fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
4379                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4380                {
4381                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4382                }
4383                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4384                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4385                }
4386            }
4387
4388            next_offset += envelope_size;
4389            _next_ordinal_to_read += 1;
4390            if next_offset >= end_offset {
4391                return Ok(());
4392            }
4393
4394            // Decode unknown envelopes for gaps in ordinals.
4395            while _next_ordinal_to_read < 5 {
4396                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4397                _next_ordinal_to_read += 1;
4398                next_offset += envelope_size;
4399            }
4400
4401            let next_out_of_line = decoder.next_out_of_line();
4402            let handles_before = decoder.remaining_handles();
4403            if let Some((inlined, num_bytes, num_handles)) =
4404                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4405            {
4406                let member_inline_size =
4407                    <DeviceSpecific as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4408                if inlined != (member_inline_size <= 4) {
4409                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4410                }
4411                let inner_offset;
4412                let mut inner_depth = depth.clone();
4413                if inlined {
4414                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4415                    inner_offset = next_offset;
4416                } else {
4417                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4418                    inner_depth.increment()?;
4419                }
4420                let val_ref =
4421                    self.device_specific.get_or_insert_with(|| fidl::new_empty!(DeviceSpecific, D));
4422                fidl::decode!(DeviceSpecific, D, val_ref, decoder, inner_offset, inner_depth)?;
4423                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4424                {
4425                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4426                }
4427                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4428                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4429                }
4430            }
4431
4432            next_offset += envelope_size;
4433
4434            // Decode the remaining unknown envelopes.
4435            while next_offset < end_offset {
4436                _next_ordinal_to_read += 1;
4437                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4438                next_offset += envelope_size;
4439            }
4440
4441            Ok(())
4442        }
4443    }
4444
4445    impl Dai {
4446        #[inline(always)]
4447        fn max_ordinal_present(&self) -> u64 {
4448            if let Some(_) = self.clock_properties {
4449                return 4;
4450            }
4451            if let Some(_) = self.dai_interconnect {
4452                return 3;
4453            }
4454            if let Some(_) = self.ring_buffer {
4455                return 2;
4456            }
4457            if let Some(_) = self.is_input {
4458                return 1;
4459            }
4460            0
4461        }
4462    }
4463
4464    impl fidl::encoding::ValueTypeMarker for Dai {
4465        type Borrowed<'a> = &'a Self;
4466        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4467            value
4468        }
4469    }
4470
4471    unsafe impl fidl::encoding::TypeMarker for Dai {
4472        type Owned = Self;
4473
4474        #[inline(always)]
4475        fn inline_align(_context: fidl::encoding::Context) -> usize {
4476            8
4477        }
4478
4479        #[inline(always)]
4480        fn inline_size(_context: fidl::encoding::Context) -> usize {
4481            16
4482        }
4483    }
4484
4485    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dai, D> for &Dai {
4486        unsafe fn encode(
4487            self,
4488            encoder: &mut fidl::encoding::Encoder<'_, D>,
4489            offset: usize,
4490            mut depth: fidl::encoding::Depth,
4491        ) -> fidl::Result<()> {
4492            encoder.debug_check_bounds::<Dai>(offset);
4493            // Vector header
4494            let max_ordinal: u64 = self.max_ordinal_present();
4495            encoder.write_num(max_ordinal, offset);
4496            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4497            // Calling encoder.out_of_line_offset(0) is not allowed.
4498            if max_ordinal == 0 {
4499                return Ok(());
4500            }
4501            depth.increment()?;
4502            let envelope_size = 8;
4503            let bytes_len = max_ordinal as usize * envelope_size;
4504            #[allow(unused_variables)]
4505            let offset = encoder.out_of_line_offset(bytes_len);
4506            let mut _prev_end_offset: usize = 0;
4507            if 1 > max_ordinal {
4508                return Ok(());
4509            }
4510
4511            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4512            // are envelope_size bytes.
4513            let cur_offset: usize = (1 - 1) * envelope_size;
4514
4515            // Zero reserved fields.
4516            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4517
4518            // Safety:
4519            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4520            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4521            //   envelope_size bytes, there is always sufficient room.
4522            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4523                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4524                encoder,
4525                offset + cur_offset,
4526                depth,
4527            )?;
4528
4529            _prev_end_offset = cur_offset + envelope_size;
4530            if 2 > max_ordinal {
4531                return Ok(());
4532            }
4533
4534            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4535            // are envelope_size bytes.
4536            let cur_offset: usize = (2 - 1) * envelope_size;
4537
4538            // Zero reserved fields.
4539            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4540
4541            // Safety:
4542            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4543            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4544            //   envelope_size bytes, there is always sufficient room.
4545            fidl::encoding::encode_in_envelope_optional::<RingBuffer, D>(
4546                self.ring_buffer
4547                    .as_ref()
4548                    .map(<RingBuffer as fidl::encoding::ValueTypeMarker>::borrow),
4549                encoder,
4550                offset + cur_offset,
4551                depth,
4552            )?;
4553
4554            _prev_end_offset = cur_offset + envelope_size;
4555            if 3 > max_ordinal {
4556                return Ok(());
4557            }
4558
4559            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4560            // are envelope_size bytes.
4561            let cur_offset: usize = (3 - 1) * envelope_size;
4562
4563            // Zero reserved fields.
4564            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4565
4566            // Safety:
4567            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4568            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4569            //   envelope_size bytes, there is always sufficient room.
4570            fidl::encoding::encode_in_envelope_optional::<DaiInterconnect, D>(
4571                self.dai_interconnect
4572                    .as_ref()
4573                    .map(<DaiInterconnect as fidl::encoding::ValueTypeMarker>::borrow),
4574                encoder,
4575                offset + cur_offset,
4576                depth,
4577            )?;
4578
4579            _prev_end_offset = cur_offset + envelope_size;
4580            if 4 > max_ordinal {
4581                return Ok(());
4582            }
4583
4584            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4585            // are envelope_size bytes.
4586            let cur_offset: usize = (4 - 1) * envelope_size;
4587
4588            // Zero reserved fields.
4589            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4590
4591            // Safety:
4592            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4593            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4594            //   envelope_size bytes, there is always sufficient room.
4595            fidl::encoding::encode_in_envelope_optional::<ClockProperties, D>(
4596                self.clock_properties
4597                    .as_ref()
4598                    .map(<ClockProperties as fidl::encoding::ValueTypeMarker>::borrow),
4599                encoder,
4600                offset + cur_offset,
4601                depth,
4602            )?;
4603
4604            _prev_end_offset = cur_offset + envelope_size;
4605
4606            Ok(())
4607        }
4608    }
4609
4610    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dai {
4611        #[inline(always)]
4612        fn new_empty() -> Self {
4613            Self::default()
4614        }
4615
4616        unsafe fn decode(
4617            &mut self,
4618            decoder: &mut fidl::encoding::Decoder<'_, D>,
4619            offset: usize,
4620            mut depth: fidl::encoding::Depth,
4621        ) -> fidl::Result<()> {
4622            decoder.debug_check_bounds::<Self>(offset);
4623            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4624                None => return Err(fidl::Error::NotNullable),
4625                Some(len) => len,
4626            };
4627            // Calling decoder.out_of_line_offset(0) is not allowed.
4628            if len == 0 {
4629                return Ok(());
4630            };
4631            depth.increment()?;
4632            let envelope_size = 8;
4633            let bytes_len = len * envelope_size;
4634            let offset = decoder.out_of_line_offset(bytes_len)?;
4635            // Decode the envelope for each type.
4636            let mut _next_ordinal_to_read = 0;
4637            let mut next_offset = offset;
4638            let end_offset = offset + bytes_len;
4639            _next_ordinal_to_read += 1;
4640            if next_offset >= end_offset {
4641                return Ok(());
4642            }
4643
4644            // Decode unknown envelopes for gaps in ordinals.
4645            while _next_ordinal_to_read < 1 {
4646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4647                _next_ordinal_to_read += 1;
4648                next_offset += envelope_size;
4649            }
4650
4651            let next_out_of_line = decoder.next_out_of_line();
4652            let handles_before = decoder.remaining_handles();
4653            if let Some((inlined, num_bytes, num_handles)) =
4654                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4655            {
4656                let member_inline_size =
4657                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4658                if inlined != (member_inline_size <= 4) {
4659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4660                }
4661                let inner_offset;
4662                let mut inner_depth = depth.clone();
4663                if inlined {
4664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4665                    inner_offset = next_offset;
4666                } else {
4667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4668                    inner_depth.increment()?;
4669                }
4670                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
4671                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4672                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4673                {
4674                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4675                }
4676                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4677                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4678                }
4679            }
4680
4681            next_offset += envelope_size;
4682            _next_ordinal_to_read += 1;
4683            if next_offset >= end_offset {
4684                return Ok(());
4685            }
4686
4687            // Decode unknown envelopes for gaps in ordinals.
4688            while _next_ordinal_to_read < 2 {
4689                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4690                _next_ordinal_to_read += 1;
4691                next_offset += envelope_size;
4692            }
4693
4694            let next_out_of_line = decoder.next_out_of_line();
4695            let handles_before = decoder.remaining_handles();
4696            if let Some((inlined, num_bytes, num_handles)) =
4697                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4698            {
4699                let member_inline_size =
4700                    <RingBuffer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4701                if inlined != (member_inline_size <= 4) {
4702                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4703                }
4704                let inner_offset;
4705                let mut inner_depth = depth.clone();
4706                if inlined {
4707                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4708                    inner_offset = next_offset;
4709                } else {
4710                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4711                    inner_depth.increment()?;
4712                }
4713                let val_ref =
4714                    self.ring_buffer.get_or_insert_with(|| fidl::new_empty!(RingBuffer, D));
4715                fidl::decode!(RingBuffer, D, val_ref, decoder, inner_offset, inner_depth)?;
4716                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4717                {
4718                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4719                }
4720                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4721                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4722                }
4723            }
4724
4725            next_offset += envelope_size;
4726            _next_ordinal_to_read += 1;
4727            if next_offset >= end_offset {
4728                return Ok(());
4729            }
4730
4731            // Decode unknown envelopes for gaps in ordinals.
4732            while _next_ordinal_to_read < 3 {
4733                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4734                _next_ordinal_to_read += 1;
4735                next_offset += envelope_size;
4736            }
4737
4738            let next_out_of_line = decoder.next_out_of_line();
4739            let handles_before = decoder.remaining_handles();
4740            if let Some((inlined, num_bytes, num_handles)) =
4741                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4742            {
4743                let member_inline_size =
4744                    <DaiInterconnect as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4745                if inlined != (member_inline_size <= 4) {
4746                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4747                }
4748                let inner_offset;
4749                let mut inner_depth = depth.clone();
4750                if inlined {
4751                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4752                    inner_offset = next_offset;
4753                } else {
4754                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4755                    inner_depth.increment()?;
4756                }
4757                let val_ref = self
4758                    .dai_interconnect
4759                    .get_or_insert_with(|| fidl::new_empty!(DaiInterconnect, D));
4760                fidl::decode!(DaiInterconnect, D, val_ref, decoder, inner_offset, inner_depth)?;
4761                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4762                {
4763                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4764                }
4765                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4766                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4767                }
4768            }
4769
4770            next_offset += envelope_size;
4771            _next_ordinal_to_read += 1;
4772            if next_offset >= end_offset {
4773                return Ok(());
4774            }
4775
4776            // Decode unknown envelopes for gaps in ordinals.
4777            while _next_ordinal_to_read < 4 {
4778                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4779                _next_ordinal_to_read += 1;
4780                next_offset += envelope_size;
4781            }
4782
4783            let next_out_of_line = decoder.next_out_of_line();
4784            let handles_before = decoder.remaining_handles();
4785            if let Some((inlined, num_bytes, num_handles)) =
4786                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4787            {
4788                let member_inline_size =
4789                    <ClockProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4790                if inlined != (member_inline_size <= 4) {
4791                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4792                }
4793                let inner_offset;
4794                let mut inner_depth = depth.clone();
4795                if inlined {
4796                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4797                    inner_offset = next_offset;
4798                } else {
4799                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4800                    inner_depth.increment()?;
4801                }
4802                let val_ref = self
4803                    .clock_properties
4804                    .get_or_insert_with(|| fidl::new_empty!(ClockProperties, D));
4805                fidl::decode!(ClockProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
4806                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4807                {
4808                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4809                }
4810                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4811                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4812                }
4813            }
4814
4815            next_offset += envelope_size;
4816
4817            // Decode the remaining unknown envelopes.
4818            while next_offset < end_offset {
4819                _next_ordinal_to_read += 1;
4820                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4821                next_offset += envelope_size;
4822            }
4823
4824            Ok(())
4825        }
4826    }
4827
4828    impl DaiInterconnect {
4829        #[inline(always)]
4830        fn max_ordinal_present(&self) -> u64 {
4831            if let Some(_) = self.dai_supported_formats {
4832                return 1;
4833            }
4834            0
4835        }
4836    }
4837
4838    impl fidl::encoding::ValueTypeMarker for DaiInterconnect {
4839        type Borrowed<'a> = &'a Self;
4840        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4841            value
4842        }
4843    }
4844
4845    unsafe impl fidl::encoding::TypeMarker for DaiInterconnect {
4846        type Owned = Self;
4847
4848        #[inline(always)]
4849        fn inline_align(_context: fidl::encoding::Context) -> usize {
4850            8
4851        }
4852
4853        #[inline(always)]
4854        fn inline_size(_context: fidl::encoding::Context) -> usize {
4855            16
4856        }
4857    }
4858
4859    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DaiInterconnect, D>
4860        for &DaiInterconnect
4861    {
4862        unsafe fn encode(
4863            self,
4864            encoder: &mut fidl::encoding::Encoder<'_, D>,
4865            offset: usize,
4866            mut depth: fidl::encoding::Depth,
4867        ) -> fidl::Result<()> {
4868            encoder.debug_check_bounds::<DaiInterconnect>(offset);
4869            // Vector header
4870            let max_ordinal: u64 = self.max_ordinal_present();
4871            encoder.write_num(max_ordinal, offset);
4872            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4873            // Calling encoder.out_of_line_offset(0) is not allowed.
4874            if max_ordinal == 0 {
4875                return Ok(());
4876            }
4877            depth.increment()?;
4878            let envelope_size = 8;
4879            let bytes_len = max_ordinal as usize * envelope_size;
4880            #[allow(unused_variables)]
4881            let offset = encoder.out_of_line_offset(bytes_len);
4882            let mut _prev_end_offset: usize = 0;
4883            if 1 > max_ordinal {
4884                return Ok(());
4885            }
4886
4887            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4888            // are envelope_size bytes.
4889            let cur_offset: usize = (1 - 1) * envelope_size;
4890
4891            // Zero reserved fields.
4892            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4893
4894            // Safety:
4895            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4896            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4897            //   envelope_size bytes, there is always sufficient room.
4898            fidl::encoding::encode_in_envelope_optional::<
4899                fidl::encoding::Vector<
4900                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4901                    64,
4902                >,
4903                D,
4904            >(
4905                self.dai_supported_formats.as_ref().map(
4906                    <fidl::encoding::Vector<
4907                        fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4908                        64,
4909                    > as fidl::encoding::ValueTypeMarker>::borrow,
4910                ),
4911                encoder,
4912                offset + cur_offset,
4913                depth,
4914            )?;
4915
4916            _prev_end_offset = cur_offset + envelope_size;
4917
4918            Ok(())
4919        }
4920    }
4921
4922    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DaiInterconnect {
4923        #[inline(always)]
4924        fn new_empty() -> Self {
4925            Self::default()
4926        }
4927
4928        unsafe fn decode(
4929            &mut self,
4930            decoder: &mut fidl::encoding::Decoder<'_, D>,
4931            offset: usize,
4932            mut depth: fidl::encoding::Depth,
4933        ) -> fidl::Result<()> {
4934            decoder.debug_check_bounds::<Self>(offset);
4935            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4936                None => return Err(fidl::Error::NotNullable),
4937                Some(len) => len,
4938            };
4939            // Calling decoder.out_of_line_offset(0) is not allowed.
4940            if len == 0 {
4941                return Ok(());
4942            };
4943            depth.increment()?;
4944            let envelope_size = 8;
4945            let bytes_len = len * envelope_size;
4946            let offset = decoder.out_of_line_offset(bytes_len)?;
4947            // Decode the envelope for each type.
4948            let mut _next_ordinal_to_read = 0;
4949            let mut next_offset = offset;
4950            let end_offset = offset + bytes_len;
4951            _next_ordinal_to_read += 1;
4952            if next_offset >= end_offset {
4953                return Ok(());
4954            }
4955
4956            // Decode unknown envelopes for gaps in ordinals.
4957            while _next_ordinal_to_read < 1 {
4958                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4959                _next_ordinal_to_read += 1;
4960                next_offset += envelope_size;
4961            }
4962
4963            let next_out_of_line = decoder.next_out_of_line();
4964            let handles_before = decoder.remaining_handles();
4965            if let Some((inlined, num_bytes, num_handles)) =
4966                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4967            {
4968                let member_inline_size = <fidl::encoding::Vector<
4969                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4970                    64,
4971                > as fidl::encoding::TypeMarker>::inline_size(
4972                    decoder.context
4973                );
4974                if inlined != (member_inline_size <= 4) {
4975                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4976                }
4977                let inner_offset;
4978                let mut inner_depth = depth.clone();
4979                if inlined {
4980                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4981                    inner_offset = next_offset;
4982                } else {
4983                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4984                    inner_depth.increment()?;
4985                }
4986                let val_ref =
4987                self.dai_supported_formats.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D));
4988                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4989                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4990                {
4991                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4992                }
4993                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4994                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4995                }
4996            }
4997
4998            next_offset += envelope_size;
4999
5000            // Decode the remaining unknown envelopes.
5001            while next_offset < end_offset {
5002                _next_ordinal_to_read += 1;
5003                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5004                next_offset += envelope_size;
5005            }
5006
5007            Ok(())
5008        }
5009    }
5010
5011    impl Direction {
5012        #[inline(always)]
5013        fn max_ordinal_present(&self) -> u64 {
5014            if let Some(_) = self.is_input {
5015                return 1;
5016            }
5017            0
5018        }
5019    }
5020
5021    impl fidl::encoding::ValueTypeMarker for Direction {
5022        type Borrowed<'a> = &'a Self;
5023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5024            value
5025        }
5026    }
5027
5028    unsafe impl fidl::encoding::TypeMarker for Direction {
5029        type Owned = Self;
5030
5031        #[inline(always)]
5032        fn inline_align(_context: fidl::encoding::Context) -> usize {
5033            8
5034        }
5035
5036        #[inline(always)]
5037        fn inline_size(_context: fidl::encoding::Context) -> usize {
5038            16
5039        }
5040    }
5041
5042    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Direction, D>
5043        for &Direction
5044    {
5045        unsafe fn encode(
5046            self,
5047            encoder: &mut fidl::encoding::Encoder<'_, D>,
5048            offset: usize,
5049            mut depth: fidl::encoding::Depth,
5050        ) -> fidl::Result<()> {
5051            encoder.debug_check_bounds::<Direction>(offset);
5052            // Vector header
5053            let max_ordinal: u64 = self.max_ordinal_present();
5054            encoder.write_num(max_ordinal, offset);
5055            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5056            // Calling encoder.out_of_line_offset(0) is not allowed.
5057            if max_ordinal == 0 {
5058                return Ok(());
5059            }
5060            depth.increment()?;
5061            let envelope_size = 8;
5062            let bytes_len = max_ordinal as usize * envelope_size;
5063            #[allow(unused_variables)]
5064            let offset = encoder.out_of_line_offset(bytes_len);
5065            let mut _prev_end_offset: usize = 0;
5066            if 1 > max_ordinal {
5067                return Ok(());
5068            }
5069
5070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5071            // are envelope_size bytes.
5072            let cur_offset: usize = (1 - 1) * envelope_size;
5073
5074            // Zero reserved fields.
5075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5076
5077            // Safety:
5078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5080            //   envelope_size bytes, there is always sufficient room.
5081            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5082                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5083                encoder,
5084                offset + cur_offset,
5085                depth,
5086            )?;
5087
5088            _prev_end_offset = cur_offset + envelope_size;
5089
5090            Ok(())
5091        }
5092    }
5093
5094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Direction {
5095        #[inline(always)]
5096        fn new_empty() -> Self {
5097            Self::default()
5098        }
5099
5100        unsafe fn decode(
5101            &mut self,
5102            decoder: &mut fidl::encoding::Decoder<'_, D>,
5103            offset: usize,
5104            mut depth: fidl::encoding::Depth,
5105        ) -> fidl::Result<()> {
5106            decoder.debug_check_bounds::<Self>(offset);
5107            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5108                None => return Err(fidl::Error::NotNullable),
5109                Some(len) => len,
5110            };
5111            // Calling decoder.out_of_line_offset(0) is not allowed.
5112            if len == 0 {
5113                return Ok(());
5114            };
5115            depth.increment()?;
5116            let envelope_size = 8;
5117            let bytes_len = len * envelope_size;
5118            let offset = decoder.out_of_line_offset(bytes_len)?;
5119            // Decode the envelope for each type.
5120            let mut _next_ordinal_to_read = 0;
5121            let mut next_offset = offset;
5122            let end_offset = offset + bytes_len;
5123            _next_ordinal_to_read += 1;
5124            if next_offset >= end_offset {
5125                return Ok(());
5126            }
5127
5128            // Decode unknown envelopes for gaps in ordinals.
5129            while _next_ordinal_to_read < 1 {
5130                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5131                _next_ordinal_to_read += 1;
5132                next_offset += envelope_size;
5133            }
5134
5135            let next_out_of_line = decoder.next_out_of_line();
5136            let handles_before = decoder.remaining_handles();
5137            if let Some((inlined, num_bytes, num_handles)) =
5138                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5139            {
5140                let member_inline_size =
5141                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5142                if inlined != (member_inline_size <= 4) {
5143                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5144                }
5145                let inner_offset;
5146                let mut inner_depth = depth.clone();
5147                if inlined {
5148                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5149                    inner_offset = next_offset;
5150                } else {
5151                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5152                    inner_depth.increment()?;
5153                }
5154                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
5155                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5156                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5157                {
5158                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5159                }
5160                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5161                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5162                }
5163            }
5164
5165            next_offset += envelope_size;
5166
5167            // Decode the remaining unknown envelopes.
5168            while next_offset < end_offset {
5169                _next_ordinal_to_read += 1;
5170                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5171                next_offset += envelope_size;
5172            }
5173
5174            Ok(())
5175        }
5176    }
5177
5178    impl GainProperties {
5179        #[inline(always)]
5180        fn max_ordinal_present(&self) -> u64 {
5181            if let Some(_) = self.can_agc {
5182                return 6;
5183            }
5184            if let Some(_) = self.can_mute {
5185                return 5;
5186            }
5187            if let Some(_) = self.gain_step_db {
5188                return 4;
5189            }
5190            if let Some(_) = self.max_gain_db {
5191                return 3;
5192            }
5193            if let Some(_) = self.min_gain_db {
5194                return 2;
5195            }
5196            if let Some(_) = self.gain_state {
5197                return 1;
5198            }
5199            0
5200        }
5201    }
5202
5203    impl fidl::encoding::ValueTypeMarker for GainProperties {
5204        type Borrowed<'a> = &'a Self;
5205        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5206            value
5207        }
5208    }
5209
5210    unsafe impl fidl::encoding::TypeMarker for GainProperties {
5211        type Owned = Self;
5212
5213        #[inline(always)]
5214        fn inline_align(_context: fidl::encoding::Context) -> usize {
5215            8
5216        }
5217
5218        #[inline(always)]
5219        fn inline_size(_context: fidl::encoding::Context) -> usize {
5220            16
5221        }
5222    }
5223
5224    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GainProperties, D>
5225        for &GainProperties
5226    {
5227        unsafe fn encode(
5228            self,
5229            encoder: &mut fidl::encoding::Encoder<'_, D>,
5230            offset: usize,
5231            mut depth: fidl::encoding::Depth,
5232        ) -> fidl::Result<()> {
5233            encoder.debug_check_bounds::<GainProperties>(offset);
5234            // Vector header
5235            let max_ordinal: u64 = self.max_ordinal_present();
5236            encoder.write_num(max_ordinal, offset);
5237            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5238            // Calling encoder.out_of_line_offset(0) is not allowed.
5239            if max_ordinal == 0 {
5240                return Ok(());
5241            }
5242            depth.increment()?;
5243            let envelope_size = 8;
5244            let bytes_len = max_ordinal as usize * envelope_size;
5245            #[allow(unused_variables)]
5246            let offset = encoder.out_of_line_offset(bytes_len);
5247            let mut _prev_end_offset: usize = 0;
5248            if 1 > max_ordinal {
5249                return Ok(());
5250            }
5251
5252            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5253            // are envelope_size bytes.
5254            let cur_offset: usize = (1 - 1) * envelope_size;
5255
5256            // Zero reserved fields.
5257            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5258
5259            // Safety:
5260            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5261            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5262            //   envelope_size bytes, there is always sufficient room.
5263            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::GainState, D>(
5264            self.gain_state.as_ref().map(<fidl_fuchsia_hardware_audio__common::GainState as fidl::encoding::ValueTypeMarker>::borrow),
5265            encoder, offset + cur_offset, depth
5266        )?;
5267
5268            _prev_end_offset = cur_offset + envelope_size;
5269            if 2 > max_ordinal {
5270                return Ok(());
5271            }
5272
5273            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5274            // are envelope_size bytes.
5275            let cur_offset: usize = (2 - 1) * envelope_size;
5276
5277            // Zero reserved fields.
5278            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5279
5280            // Safety:
5281            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5282            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5283            //   envelope_size bytes, there is always sufficient room.
5284            fidl::encoding::encode_in_envelope_optional::<f32, D>(
5285                self.min_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
5286                encoder,
5287                offset + cur_offset,
5288                depth,
5289            )?;
5290
5291            _prev_end_offset = cur_offset + envelope_size;
5292            if 3 > max_ordinal {
5293                return Ok(());
5294            }
5295
5296            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5297            // are envelope_size bytes.
5298            let cur_offset: usize = (3 - 1) * envelope_size;
5299
5300            // Zero reserved fields.
5301            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5302
5303            // Safety:
5304            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5305            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5306            //   envelope_size bytes, there is always sufficient room.
5307            fidl::encoding::encode_in_envelope_optional::<f32, D>(
5308                self.max_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
5309                encoder,
5310                offset + cur_offset,
5311                depth,
5312            )?;
5313
5314            _prev_end_offset = cur_offset + envelope_size;
5315            if 4 > max_ordinal {
5316                return Ok(());
5317            }
5318
5319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5320            // are envelope_size bytes.
5321            let cur_offset: usize = (4 - 1) * envelope_size;
5322
5323            // Zero reserved fields.
5324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5325
5326            // Safety:
5327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5329            //   envelope_size bytes, there is always sufficient room.
5330            fidl::encoding::encode_in_envelope_optional::<f32, D>(
5331                self.gain_step_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
5332                encoder,
5333                offset + cur_offset,
5334                depth,
5335            )?;
5336
5337            _prev_end_offset = cur_offset + envelope_size;
5338            if 5 > max_ordinal {
5339                return Ok(());
5340            }
5341
5342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5343            // are envelope_size bytes.
5344            let cur_offset: usize = (5 - 1) * envelope_size;
5345
5346            // Zero reserved fields.
5347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5348
5349            // Safety:
5350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5352            //   envelope_size bytes, there is always sufficient room.
5353            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5354                self.can_mute.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5355                encoder,
5356                offset + cur_offset,
5357                depth,
5358            )?;
5359
5360            _prev_end_offset = cur_offset + envelope_size;
5361            if 6 > max_ordinal {
5362                return Ok(());
5363            }
5364
5365            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5366            // are envelope_size bytes.
5367            let cur_offset: usize = (6 - 1) * envelope_size;
5368
5369            // Zero reserved fields.
5370            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5371
5372            // Safety:
5373            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5374            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5375            //   envelope_size bytes, there is always sufficient room.
5376            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5377                self.can_agc.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5378                encoder,
5379                offset + cur_offset,
5380                depth,
5381            )?;
5382
5383            _prev_end_offset = cur_offset + envelope_size;
5384
5385            Ok(())
5386        }
5387    }
5388
5389    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainProperties {
5390        #[inline(always)]
5391        fn new_empty() -> Self {
5392            Self::default()
5393        }
5394
5395        unsafe fn decode(
5396            &mut self,
5397            decoder: &mut fidl::encoding::Decoder<'_, D>,
5398            offset: usize,
5399            mut depth: fidl::encoding::Depth,
5400        ) -> fidl::Result<()> {
5401            decoder.debug_check_bounds::<Self>(offset);
5402            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5403                None => return Err(fidl::Error::NotNullable),
5404                Some(len) => len,
5405            };
5406            // Calling decoder.out_of_line_offset(0) is not allowed.
5407            if len == 0 {
5408                return Ok(());
5409            };
5410            depth.increment()?;
5411            let envelope_size = 8;
5412            let bytes_len = len * envelope_size;
5413            let offset = decoder.out_of_line_offset(bytes_len)?;
5414            // Decode the envelope for each type.
5415            let mut _next_ordinal_to_read = 0;
5416            let mut next_offset = offset;
5417            let end_offset = offset + bytes_len;
5418            _next_ordinal_to_read += 1;
5419            if next_offset >= end_offset {
5420                return Ok(());
5421            }
5422
5423            // Decode unknown envelopes for gaps in ordinals.
5424            while _next_ordinal_to_read < 1 {
5425                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5426                _next_ordinal_to_read += 1;
5427                next_offset += envelope_size;
5428            }
5429
5430            let next_out_of_line = decoder.next_out_of_line();
5431            let handles_before = decoder.remaining_handles();
5432            if let Some((inlined, num_bytes, num_handles)) =
5433                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5434            {
5435                let member_inline_size = <fidl_fuchsia_hardware_audio__common::GainState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5436                if inlined != (member_inline_size <= 4) {
5437                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5438                }
5439                let inner_offset;
5440                let mut inner_depth = depth.clone();
5441                if inlined {
5442                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5443                    inner_offset = next_offset;
5444                } else {
5445                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5446                    inner_depth.increment()?;
5447                }
5448                let val_ref = self.gain_state.get_or_insert_with(|| {
5449                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::GainState, D)
5450                });
5451                fidl::decode!(
5452                    fidl_fuchsia_hardware_audio__common::GainState,
5453                    D,
5454                    val_ref,
5455                    decoder,
5456                    inner_offset,
5457                    inner_depth
5458                )?;
5459                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5460                {
5461                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5462                }
5463                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5464                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5465                }
5466            }
5467
5468            next_offset += envelope_size;
5469            _next_ordinal_to_read += 1;
5470            if next_offset >= end_offset {
5471                return Ok(());
5472            }
5473
5474            // Decode unknown envelopes for gaps in ordinals.
5475            while _next_ordinal_to_read < 2 {
5476                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5477                _next_ordinal_to_read += 1;
5478                next_offset += envelope_size;
5479            }
5480
5481            let next_out_of_line = decoder.next_out_of_line();
5482            let handles_before = decoder.remaining_handles();
5483            if let Some((inlined, num_bytes, num_handles)) =
5484                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5485            {
5486                let member_inline_size =
5487                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5488                if inlined != (member_inline_size <= 4) {
5489                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5490                }
5491                let inner_offset;
5492                let mut inner_depth = depth.clone();
5493                if inlined {
5494                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5495                    inner_offset = next_offset;
5496                } else {
5497                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5498                    inner_depth.increment()?;
5499                }
5500                let val_ref = self.min_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
5501                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
5502                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5503                {
5504                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5505                }
5506                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5507                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5508                }
5509            }
5510
5511            next_offset += envelope_size;
5512            _next_ordinal_to_read += 1;
5513            if next_offset >= end_offset {
5514                return Ok(());
5515            }
5516
5517            // Decode unknown envelopes for gaps in ordinals.
5518            while _next_ordinal_to_read < 3 {
5519                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5520                _next_ordinal_to_read += 1;
5521                next_offset += envelope_size;
5522            }
5523
5524            let next_out_of_line = decoder.next_out_of_line();
5525            let handles_before = decoder.remaining_handles();
5526            if let Some((inlined, num_bytes, num_handles)) =
5527                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5528            {
5529                let member_inline_size =
5530                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5531                if inlined != (member_inline_size <= 4) {
5532                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5533                }
5534                let inner_offset;
5535                let mut inner_depth = depth.clone();
5536                if inlined {
5537                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5538                    inner_offset = next_offset;
5539                } else {
5540                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5541                    inner_depth.increment()?;
5542                }
5543                let val_ref = self.max_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
5544                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
5545                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5546                {
5547                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5548                }
5549                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5550                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5551                }
5552            }
5553
5554            next_offset += envelope_size;
5555            _next_ordinal_to_read += 1;
5556            if next_offset >= end_offset {
5557                return Ok(());
5558            }
5559
5560            // Decode unknown envelopes for gaps in ordinals.
5561            while _next_ordinal_to_read < 4 {
5562                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5563                _next_ordinal_to_read += 1;
5564                next_offset += envelope_size;
5565            }
5566
5567            let next_out_of_line = decoder.next_out_of_line();
5568            let handles_before = decoder.remaining_handles();
5569            if let Some((inlined, num_bytes, num_handles)) =
5570                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5571            {
5572                let member_inline_size =
5573                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5574                if inlined != (member_inline_size <= 4) {
5575                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5576                }
5577                let inner_offset;
5578                let mut inner_depth = depth.clone();
5579                if inlined {
5580                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5581                    inner_offset = next_offset;
5582                } else {
5583                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5584                    inner_depth.increment()?;
5585                }
5586                let val_ref = self.gain_step_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
5587                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
5588                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5589                {
5590                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5591                }
5592                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5593                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5594                }
5595            }
5596
5597            next_offset += envelope_size;
5598            _next_ordinal_to_read += 1;
5599            if next_offset >= end_offset {
5600                return Ok(());
5601            }
5602
5603            // Decode unknown envelopes for gaps in ordinals.
5604            while _next_ordinal_to_read < 5 {
5605                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5606                _next_ordinal_to_read += 1;
5607                next_offset += envelope_size;
5608            }
5609
5610            let next_out_of_line = decoder.next_out_of_line();
5611            let handles_before = decoder.remaining_handles();
5612            if let Some((inlined, num_bytes, num_handles)) =
5613                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5614            {
5615                let member_inline_size =
5616                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5617                if inlined != (member_inline_size <= 4) {
5618                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5619                }
5620                let inner_offset;
5621                let mut inner_depth = depth.clone();
5622                if inlined {
5623                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5624                    inner_offset = next_offset;
5625                } else {
5626                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5627                    inner_depth.increment()?;
5628                }
5629                let val_ref = self.can_mute.get_or_insert_with(|| fidl::new_empty!(bool, D));
5630                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5631                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5632                {
5633                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5634                }
5635                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5636                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5637                }
5638            }
5639
5640            next_offset += envelope_size;
5641            _next_ordinal_to_read += 1;
5642            if next_offset >= end_offset {
5643                return Ok(());
5644            }
5645
5646            // Decode unknown envelopes for gaps in ordinals.
5647            while _next_ordinal_to_read < 6 {
5648                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5649                _next_ordinal_to_read += 1;
5650                next_offset += envelope_size;
5651            }
5652
5653            let next_out_of_line = decoder.next_out_of_line();
5654            let handles_before = decoder.remaining_handles();
5655            if let Some((inlined, num_bytes, num_handles)) =
5656                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5657            {
5658                let member_inline_size =
5659                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5660                if inlined != (member_inline_size <= 4) {
5661                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5662                }
5663                let inner_offset;
5664                let mut inner_depth = depth.clone();
5665                if inlined {
5666                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5667                    inner_offset = next_offset;
5668                } else {
5669                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5670                    inner_depth.increment()?;
5671                }
5672                let val_ref = self.can_agc.get_or_insert_with(|| fidl::new_empty!(bool, D));
5673                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5674                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5675                {
5676                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5677                }
5678                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5679                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5680                }
5681            }
5682
5683            next_offset += envelope_size;
5684
5685            // Decode the remaining unknown envelopes.
5686            while next_offset < end_offset {
5687                _next_ordinal_to_read += 1;
5688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5689                next_offset += envelope_size;
5690            }
5691
5692            Ok(())
5693        }
5694    }
5695
5696    impl PlugProperties {
5697        #[inline(always)]
5698        fn max_ordinal_present(&self) -> u64 {
5699            if let Some(_) = self.plug_detect_capabilities {
5700                return 2;
5701            }
5702            if let Some(_) = self.plug_state {
5703                return 1;
5704            }
5705            0
5706        }
5707    }
5708
5709    impl fidl::encoding::ValueTypeMarker for PlugProperties {
5710        type Borrowed<'a> = &'a Self;
5711        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5712            value
5713        }
5714    }
5715
5716    unsafe impl fidl::encoding::TypeMarker for PlugProperties {
5717        type Owned = Self;
5718
5719        #[inline(always)]
5720        fn inline_align(_context: fidl::encoding::Context) -> usize {
5721            8
5722        }
5723
5724        #[inline(always)]
5725        fn inline_size(_context: fidl::encoding::Context) -> usize {
5726            16
5727        }
5728    }
5729
5730    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PlugProperties, D>
5731        for &PlugProperties
5732    {
5733        unsafe fn encode(
5734            self,
5735            encoder: &mut fidl::encoding::Encoder<'_, D>,
5736            offset: usize,
5737            mut depth: fidl::encoding::Depth,
5738        ) -> fidl::Result<()> {
5739            encoder.debug_check_bounds::<PlugProperties>(offset);
5740            // Vector header
5741            let max_ordinal: u64 = self.max_ordinal_present();
5742            encoder.write_num(max_ordinal, offset);
5743            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5744            // Calling encoder.out_of_line_offset(0) is not allowed.
5745            if max_ordinal == 0 {
5746                return Ok(());
5747            }
5748            depth.increment()?;
5749            let envelope_size = 8;
5750            let bytes_len = max_ordinal as usize * envelope_size;
5751            #[allow(unused_variables)]
5752            let offset = encoder.out_of_line_offset(bytes_len);
5753            let mut _prev_end_offset: usize = 0;
5754            if 1 > max_ordinal {
5755                return Ok(());
5756            }
5757
5758            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5759            // are envelope_size bytes.
5760            let cur_offset: usize = (1 - 1) * envelope_size;
5761
5762            // Zero reserved fields.
5763            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5764
5765            // Safety:
5766            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5767            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5768            //   envelope_size bytes, there is always sufficient room.
5769            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::PlugState, D>(
5770            self.plug_state.as_ref().map(<fidl_fuchsia_hardware_audio__common::PlugState as fidl::encoding::ValueTypeMarker>::borrow),
5771            encoder, offset + cur_offset, depth
5772        )?;
5773
5774            _prev_end_offset = cur_offset + envelope_size;
5775            if 2 > max_ordinal {
5776                return Ok(());
5777            }
5778
5779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5780            // are envelope_size bytes.
5781            let cur_offset: usize = (2 - 1) * envelope_size;
5782
5783            // Zero reserved fields.
5784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5785
5786            // Safety:
5787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5789            //   envelope_size bytes, there is always sufficient room.
5790            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities, D>(
5791            self.plug_detect_capabilities.as_ref().map(<fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
5792            encoder, offset + cur_offset, depth
5793        )?;
5794
5795            _prev_end_offset = cur_offset + envelope_size;
5796
5797            Ok(())
5798        }
5799    }
5800
5801    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugProperties {
5802        #[inline(always)]
5803        fn new_empty() -> Self {
5804            Self::default()
5805        }
5806
5807        unsafe fn decode(
5808            &mut self,
5809            decoder: &mut fidl::encoding::Decoder<'_, D>,
5810            offset: usize,
5811            mut depth: fidl::encoding::Depth,
5812        ) -> fidl::Result<()> {
5813            decoder.debug_check_bounds::<Self>(offset);
5814            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5815                None => return Err(fidl::Error::NotNullable),
5816                Some(len) => len,
5817            };
5818            // Calling decoder.out_of_line_offset(0) is not allowed.
5819            if len == 0 {
5820                return Ok(());
5821            };
5822            depth.increment()?;
5823            let envelope_size = 8;
5824            let bytes_len = len * envelope_size;
5825            let offset = decoder.out_of_line_offset(bytes_len)?;
5826            // Decode the envelope for each type.
5827            let mut _next_ordinal_to_read = 0;
5828            let mut next_offset = offset;
5829            let end_offset = offset + bytes_len;
5830            _next_ordinal_to_read += 1;
5831            if next_offset >= end_offset {
5832                return Ok(());
5833            }
5834
5835            // Decode unknown envelopes for gaps in ordinals.
5836            while _next_ordinal_to_read < 1 {
5837                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5838                _next_ordinal_to_read += 1;
5839                next_offset += envelope_size;
5840            }
5841
5842            let next_out_of_line = decoder.next_out_of_line();
5843            let handles_before = decoder.remaining_handles();
5844            if let Some((inlined, num_bytes, num_handles)) =
5845                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5846            {
5847                let member_inline_size = <fidl_fuchsia_hardware_audio__common::PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5848                if inlined != (member_inline_size <= 4) {
5849                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5850                }
5851                let inner_offset;
5852                let mut inner_depth = depth.clone();
5853                if inlined {
5854                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5855                    inner_offset = next_offset;
5856                } else {
5857                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5858                    inner_depth.increment()?;
5859                }
5860                let val_ref = self.plug_state.get_or_insert_with(|| {
5861                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::PlugState, D)
5862                });
5863                fidl::decode!(
5864                    fidl_fuchsia_hardware_audio__common::PlugState,
5865                    D,
5866                    val_ref,
5867                    decoder,
5868                    inner_offset,
5869                    inner_depth
5870                )?;
5871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5872                {
5873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5874                }
5875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5877                }
5878            }
5879
5880            next_offset += envelope_size;
5881            _next_ordinal_to_read += 1;
5882            if next_offset >= end_offset {
5883                return Ok(());
5884            }
5885
5886            // Decode unknown envelopes for gaps in ordinals.
5887            while _next_ordinal_to_read < 2 {
5888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5889                _next_ordinal_to_read += 1;
5890                next_offset += envelope_size;
5891            }
5892
5893            let next_out_of_line = decoder.next_out_of_line();
5894            let handles_before = decoder.remaining_handles();
5895            if let Some((inlined, num_bytes, num_handles)) =
5896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5897            {
5898                let member_inline_size = <fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5899                if inlined != (member_inline_size <= 4) {
5900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5901                }
5902                let inner_offset;
5903                let mut inner_depth = depth.clone();
5904                if inlined {
5905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5906                    inner_offset = next_offset;
5907                } else {
5908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5909                    inner_depth.increment()?;
5910                }
5911                let val_ref = self.plug_detect_capabilities.get_or_insert_with(|| {
5912                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities, D)
5913                });
5914                fidl::decode!(
5915                    fidl_fuchsia_hardware_audio__common::PlugDetectCapabilities,
5916                    D,
5917                    val_ref,
5918                    decoder,
5919                    inner_offset,
5920                    inner_depth
5921                )?;
5922                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5923                {
5924                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5925                }
5926                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5927                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5928                }
5929            }
5930
5931            next_offset += envelope_size;
5932
5933            // Decode the remaining unknown envelopes.
5934            while next_offset < end_offset {
5935                _next_ordinal_to_read += 1;
5936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5937                next_offset += envelope_size;
5938            }
5939
5940            Ok(())
5941        }
5942    }
5943
5944    impl RingBuffer {
5945        #[inline(always)]
5946        fn max_ordinal_present(&self) -> u64 {
5947            if let Some(_) = self.notifications_per_ring {
5948                return 6;
5949            }
5950            if let Some(_) = self.ring_buffer_constraints {
5951                return 5;
5952            }
5953            if let Some(_) = self.supported_formats {
5954                return 4;
5955            }
5956            if let Some(_) = self.external_delay {
5957                return 3;
5958            }
5959            if let Some(_) = self.internal_delay {
5960                return 2;
5961            }
5962            if let Some(_) = self.driver_transfer_bytes {
5963                return 1;
5964            }
5965            0
5966        }
5967    }
5968
5969    impl fidl::encoding::ValueTypeMarker for RingBuffer {
5970        type Borrowed<'a> = &'a Self;
5971        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5972            value
5973        }
5974    }
5975
5976    unsafe impl fidl::encoding::TypeMarker for RingBuffer {
5977        type Owned = Self;
5978
5979        #[inline(always)]
5980        fn inline_align(_context: fidl::encoding::Context) -> usize {
5981            8
5982        }
5983
5984        #[inline(always)]
5985        fn inline_size(_context: fidl::encoding::Context) -> usize {
5986            16
5987        }
5988    }
5989
5990    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBuffer, D>
5991        for &RingBuffer
5992    {
5993        unsafe fn encode(
5994            self,
5995            encoder: &mut fidl::encoding::Encoder<'_, D>,
5996            offset: usize,
5997            mut depth: fidl::encoding::Depth,
5998        ) -> fidl::Result<()> {
5999            encoder.debug_check_bounds::<RingBuffer>(offset);
6000            // Vector header
6001            let max_ordinal: u64 = self.max_ordinal_present();
6002            encoder.write_num(max_ordinal, offset);
6003            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6004            // Calling encoder.out_of_line_offset(0) is not allowed.
6005            if max_ordinal == 0 {
6006                return Ok(());
6007            }
6008            depth.increment()?;
6009            let envelope_size = 8;
6010            let bytes_len = max_ordinal as usize * envelope_size;
6011            #[allow(unused_variables)]
6012            let offset = encoder.out_of_line_offset(bytes_len);
6013            let mut _prev_end_offset: usize = 0;
6014            if 1 > max_ordinal {
6015                return Ok(());
6016            }
6017
6018            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6019            // are envelope_size bytes.
6020            let cur_offset: usize = (1 - 1) * envelope_size;
6021
6022            // Zero reserved fields.
6023            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6024
6025            // Safety:
6026            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6027            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6028            //   envelope_size bytes, there is always sufficient room.
6029            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6030                self.driver_transfer_bytes
6031                    .as_ref()
6032                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6033                encoder,
6034                offset + cur_offset,
6035                depth,
6036            )?;
6037
6038            _prev_end_offset = cur_offset + envelope_size;
6039            if 2 > max_ordinal {
6040                return Ok(());
6041            }
6042
6043            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6044            // are envelope_size bytes.
6045            let cur_offset: usize = (2 - 1) * envelope_size;
6046
6047            // Zero reserved fields.
6048            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6049
6050            // Safety:
6051            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6052            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6053            //   envelope_size bytes, there is always sufficient room.
6054            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6055                self.internal_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6056                encoder,
6057                offset + cur_offset,
6058                depth,
6059            )?;
6060
6061            _prev_end_offset = cur_offset + envelope_size;
6062            if 3 > max_ordinal {
6063                return Ok(());
6064            }
6065
6066            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6067            // are envelope_size bytes.
6068            let cur_offset: usize = (3 - 1) * envelope_size;
6069
6070            // Zero reserved fields.
6071            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6072
6073            // Safety:
6074            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6075            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6076            //   envelope_size bytes, there is always sufficient room.
6077            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6078                self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6079                encoder,
6080                offset + cur_offset,
6081                depth,
6082            )?;
6083
6084            _prev_end_offset = cur_offset + envelope_size;
6085            if 4 > max_ordinal {
6086                return Ok(());
6087            }
6088
6089            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6090            // are envelope_size bytes.
6091            let cur_offset: usize = (4 - 1) * envelope_size;
6092
6093            // Zero reserved fields.
6094            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6095
6096            // Safety:
6097            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6098            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6099            //   envelope_size bytes, there is always sufficient room.
6100            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<FormatRange, 64>, D>(
6101            self.supported_formats.as_ref().map(<fidl::encoding::Vector<FormatRange, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6102            encoder, offset + cur_offset, depth
6103        )?;
6104
6105            _prev_end_offset = cur_offset + envelope_size;
6106            if 5 > max_ordinal {
6107                return Ok(());
6108            }
6109
6110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6111            // are envelope_size bytes.
6112            let cur_offset: usize = (5 - 1) * envelope_size;
6113
6114            // Zero reserved fields.
6115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6116
6117            // Safety:
6118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6120            //   envelope_size bytes, there is always sufficient room.
6121            fidl::encoding::encode_in_envelope_optional::<RingBufferConstraints, D>(
6122                self.ring_buffer_constraints
6123                    .as_ref()
6124                    .map(<RingBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow),
6125                encoder,
6126                offset + cur_offset,
6127                depth,
6128            )?;
6129
6130            _prev_end_offset = cur_offset + envelope_size;
6131            if 6 > max_ordinal {
6132                return Ok(());
6133            }
6134
6135            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6136            // are envelope_size bytes.
6137            let cur_offset: usize = (6 - 1) * envelope_size;
6138
6139            // Zero reserved fields.
6140            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6141
6142            // Safety:
6143            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6144            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6145            //   envelope_size bytes, there is always sufficient room.
6146            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6147                self.notifications_per_ring
6148                    .as_ref()
6149                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6150                encoder,
6151                offset + cur_offset,
6152                depth,
6153            )?;
6154
6155            _prev_end_offset = cur_offset + envelope_size;
6156
6157            Ok(())
6158        }
6159    }
6160
6161    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBuffer {
6162        #[inline(always)]
6163        fn new_empty() -> Self {
6164            Self::default()
6165        }
6166
6167        unsafe fn decode(
6168            &mut self,
6169            decoder: &mut fidl::encoding::Decoder<'_, D>,
6170            offset: usize,
6171            mut depth: fidl::encoding::Depth,
6172        ) -> fidl::Result<()> {
6173            decoder.debug_check_bounds::<Self>(offset);
6174            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6175                None => return Err(fidl::Error::NotNullable),
6176                Some(len) => len,
6177            };
6178            // Calling decoder.out_of_line_offset(0) is not allowed.
6179            if len == 0 {
6180                return Ok(());
6181            };
6182            depth.increment()?;
6183            let envelope_size = 8;
6184            let bytes_len = len * envelope_size;
6185            let offset = decoder.out_of_line_offset(bytes_len)?;
6186            // Decode the envelope for each type.
6187            let mut _next_ordinal_to_read = 0;
6188            let mut next_offset = offset;
6189            let end_offset = offset + bytes_len;
6190            _next_ordinal_to_read += 1;
6191            if next_offset >= end_offset {
6192                return Ok(());
6193            }
6194
6195            // Decode unknown envelopes for gaps in ordinals.
6196            while _next_ordinal_to_read < 1 {
6197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6198                _next_ordinal_to_read += 1;
6199                next_offset += envelope_size;
6200            }
6201
6202            let next_out_of_line = decoder.next_out_of_line();
6203            let handles_before = decoder.remaining_handles();
6204            if let Some((inlined, num_bytes, num_handles)) =
6205                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6206            {
6207                let member_inline_size =
6208                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6209                if inlined != (member_inline_size <= 4) {
6210                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6211                }
6212                let inner_offset;
6213                let mut inner_depth = depth.clone();
6214                if inlined {
6215                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6216                    inner_offset = next_offset;
6217                } else {
6218                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6219                    inner_depth.increment()?;
6220                }
6221                let val_ref =
6222                    self.driver_transfer_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
6223                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6225                {
6226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6227                }
6228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6230                }
6231            }
6232
6233            next_offset += envelope_size;
6234            _next_ordinal_to_read += 1;
6235            if next_offset >= end_offset {
6236                return Ok(());
6237            }
6238
6239            // Decode unknown envelopes for gaps in ordinals.
6240            while _next_ordinal_to_read < 2 {
6241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6242                _next_ordinal_to_read += 1;
6243                next_offset += envelope_size;
6244            }
6245
6246            let next_out_of_line = decoder.next_out_of_line();
6247            let handles_before = decoder.remaining_handles();
6248            if let Some((inlined, num_bytes, num_handles)) =
6249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6250            {
6251                let member_inline_size =
6252                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6253                if inlined != (member_inline_size <= 4) {
6254                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6255                }
6256                let inner_offset;
6257                let mut inner_depth = depth.clone();
6258                if inlined {
6259                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6260                    inner_offset = next_offset;
6261                } else {
6262                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6263                    inner_depth.increment()?;
6264                }
6265                let val_ref = self.internal_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6266                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6267                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6268                {
6269                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6270                }
6271                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6272                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6273                }
6274            }
6275
6276            next_offset += envelope_size;
6277            _next_ordinal_to_read += 1;
6278            if next_offset >= end_offset {
6279                return Ok(());
6280            }
6281
6282            // Decode unknown envelopes for gaps in ordinals.
6283            while _next_ordinal_to_read < 3 {
6284                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6285                _next_ordinal_to_read += 1;
6286                next_offset += envelope_size;
6287            }
6288
6289            let next_out_of_line = decoder.next_out_of_line();
6290            let handles_before = decoder.remaining_handles();
6291            if let Some((inlined, num_bytes, num_handles)) =
6292                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6293            {
6294                let member_inline_size =
6295                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6296                if inlined != (member_inline_size <= 4) {
6297                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6298                }
6299                let inner_offset;
6300                let mut inner_depth = depth.clone();
6301                if inlined {
6302                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6303                    inner_offset = next_offset;
6304                } else {
6305                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6306                    inner_depth.increment()?;
6307                }
6308                let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6309                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6310                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6311                {
6312                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6313                }
6314                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6315                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6316                }
6317            }
6318
6319            next_offset += envelope_size;
6320            _next_ordinal_to_read += 1;
6321            if next_offset >= end_offset {
6322                return Ok(());
6323            }
6324
6325            // Decode unknown envelopes for gaps in ordinals.
6326            while _next_ordinal_to_read < 4 {
6327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6328                _next_ordinal_to_read += 1;
6329                next_offset += envelope_size;
6330            }
6331
6332            let next_out_of_line = decoder.next_out_of_line();
6333            let handles_before = decoder.remaining_handles();
6334            if let Some((inlined, num_bytes, num_handles)) =
6335                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6336            {
6337                let member_inline_size = <fidl::encoding::Vector<FormatRange, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6338                if inlined != (member_inline_size <= 4) {
6339                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6340                }
6341                let inner_offset;
6342                let mut inner_depth = depth.clone();
6343                if inlined {
6344                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6345                    inner_offset = next_offset;
6346                } else {
6347                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6348                    inner_depth.increment()?;
6349                }
6350                let val_ref = self.supported_formats.get_or_insert_with(
6351                    || fidl::new_empty!(fidl::encoding::Vector<FormatRange, 64>, D),
6352                );
6353                fidl::decode!(fidl::encoding::Vector<FormatRange, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6355                {
6356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6357                }
6358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6360                }
6361            }
6362
6363            next_offset += envelope_size;
6364            _next_ordinal_to_read += 1;
6365            if next_offset >= end_offset {
6366                return Ok(());
6367            }
6368
6369            // Decode unknown envelopes for gaps in ordinals.
6370            while _next_ordinal_to_read < 5 {
6371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6372                _next_ordinal_to_read += 1;
6373                next_offset += envelope_size;
6374            }
6375
6376            let next_out_of_line = decoder.next_out_of_line();
6377            let handles_before = decoder.remaining_handles();
6378            if let Some((inlined, num_bytes, num_handles)) =
6379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6380            {
6381                let member_inline_size =
6382                    <RingBufferConstraints as fidl::encoding::TypeMarker>::inline_size(
6383                        decoder.context,
6384                    );
6385                if inlined != (member_inline_size <= 4) {
6386                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6387                }
6388                let inner_offset;
6389                let mut inner_depth = depth.clone();
6390                if inlined {
6391                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6392                    inner_offset = next_offset;
6393                } else {
6394                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6395                    inner_depth.increment()?;
6396                }
6397                let val_ref = self
6398                    .ring_buffer_constraints
6399                    .get_or_insert_with(|| fidl::new_empty!(RingBufferConstraints, D));
6400                fidl::decode!(
6401                    RingBufferConstraints,
6402                    D,
6403                    val_ref,
6404                    decoder,
6405                    inner_offset,
6406                    inner_depth
6407                )?;
6408                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6409                {
6410                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6411                }
6412                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6413                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6414                }
6415            }
6416
6417            next_offset += envelope_size;
6418            _next_ordinal_to_read += 1;
6419            if next_offset >= end_offset {
6420                return Ok(());
6421            }
6422
6423            // Decode unknown envelopes for gaps in ordinals.
6424            while _next_ordinal_to_read < 6 {
6425                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6426                _next_ordinal_to_read += 1;
6427                next_offset += envelope_size;
6428            }
6429
6430            let next_out_of_line = decoder.next_out_of_line();
6431            let handles_before = decoder.remaining_handles();
6432            if let Some((inlined, num_bytes, num_handles)) =
6433                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6434            {
6435                let member_inline_size =
6436                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6437                if inlined != (member_inline_size <= 4) {
6438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6439                }
6440                let inner_offset;
6441                let mut inner_depth = depth.clone();
6442                if inlined {
6443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6444                    inner_offset = next_offset;
6445                } else {
6446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6447                    inner_depth.increment()?;
6448                }
6449                let val_ref =
6450                    self.notifications_per_ring.get_or_insert_with(|| fidl::new_empty!(u32, D));
6451                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6452                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6453                {
6454                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6455                }
6456                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6457                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6458                }
6459            }
6460
6461            next_offset += envelope_size;
6462
6463            // Decode the remaining unknown envelopes.
6464            while next_offset < end_offset {
6465                _next_ordinal_to_read += 1;
6466                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6467                next_offset += envelope_size;
6468            }
6469
6470            Ok(())
6471        }
6472    }
6473
6474    impl StreamConfig {
6475        #[inline(always)]
6476        fn max_ordinal_present(&self) -> u64 {
6477            if let Some(_) = self.plug_properties {
6478                return 5;
6479            }
6480            if let Some(_) = self.gain_properties {
6481                return 4;
6482            }
6483            if let Some(_) = self.clock_properties {
6484                return 3;
6485            }
6486            if let Some(_) = self.ring_buffer {
6487                return 2;
6488            }
6489            if let Some(_) = self.is_input {
6490                return 1;
6491            }
6492            0
6493        }
6494    }
6495
6496    impl fidl::encoding::ValueTypeMarker for StreamConfig {
6497        type Borrowed<'a> = &'a Self;
6498        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6499            value
6500        }
6501    }
6502
6503    unsafe impl fidl::encoding::TypeMarker for StreamConfig {
6504        type Owned = Self;
6505
6506        #[inline(always)]
6507        fn inline_align(_context: fidl::encoding::Context) -> usize {
6508            8
6509        }
6510
6511        #[inline(always)]
6512        fn inline_size(_context: fidl::encoding::Context) -> usize {
6513            16
6514        }
6515    }
6516
6517    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamConfig, D>
6518        for &StreamConfig
6519    {
6520        unsafe fn encode(
6521            self,
6522            encoder: &mut fidl::encoding::Encoder<'_, D>,
6523            offset: usize,
6524            mut depth: fidl::encoding::Depth,
6525        ) -> fidl::Result<()> {
6526            encoder.debug_check_bounds::<StreamConfig>(offset);
6527            // Vector header
6528            let max_ordinal: u64 = self.max_ordinal_present();
6529            encoder.write_num(max_ordinal, offset);
6530            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6531            // Calling encoder.out_of_line_offset(0) is not allowed.
6532            if max_ordinal == 0 {
6533                return Ok(());
6534            }
6535            depth.increment()?;
6536            let envelope_size = 8;
6537            let bytes_len = max_ordinal as usize * envelope_size;
6538            #[allow(unused_variables)]
6539            let offset = encoder.out_of_line_offset(bytes_len);
6540            let mut _prev_end_offset: usize = 0;
6541            if 1 > max_ordinal {
6542                return Ok(());
6543            }
6544
6545            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6546            // are envelope_size bytes.
6547            let cur_offset: usize = (1 - 1) * envelope_size;
6548
6549            // Zero reserved fields.
6550            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6551
6552            // Safety:
6553            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6554            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6555            //   envelope_size bytes, there is always sufficient room.
6556            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6557                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6558                encoder,
6559                offset + cur_offset,
6560                depth,
6561            )?;
6562
6563            _prev_end_offset = cur_offset + envelope_size;
6564            if 2 > max_ordinal {
6565                return Ok(());
6566            }
6567
6568            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6569            // are envelope_size bytes.
6570            let cur_offset: usize = (2 - 1) * envelope_size;
6571
6572            // Zero reserved fields.
6573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6574
6575            // Safety:
6576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6578            //   envelope_size bytes, there is always sufficient room.
6579            fidl::encoding::encode_in_envelope_optional::<RingBuffer, D>(
6580                self.ring_buffer
6581                    .as_ref()
6582                    .map(<RingBuffer as fidl::encoding::ValueTypeMarker>::borrow),
6583                encoder,
6584                offset + cur_offset,
6585                depth,
6586            )?;
6587
6588            _prev_end_offset = cur_offset + envelope_size;
6589            if 3 > max_ordinal {
6590                return Ok(());
6591            }
6592
6593            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6594            // are envelope_size bytes.
6595            let cur_offset: usize = (3 - 1) * envelope_size;
6596
6597            // Zero reserved fields.
6598            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6599
6600            // Safety:
6601            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6602            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6603            //   envelope_size bytes, there is always sufficient room.
6604            fidl::encoding::encode_in_envelope_optional::<ClockProperties, D>(
6605                self.clock_properties
6606                    .as_ref()
6607                    .map(<ClockProperties as fidl::encoding::ValueTypeMarker>::borrow),
6608                encoder,
6609                offset + cur_offset,
6610                depth,
6611            )?;
6612
6613            _prev_end_offset = cur_offset + envelope_size;
6614            if 4 > max_ordinal {
6615                return Ok(());
6616            }
6617
6618            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6619            // are envelope_size bytes.
6620            let cur_offset: usize = (4 - 1) * envelope_size;
6621
6622            // Zero reserved fields.
6623            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6624
6625            // Safety:
6626            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6627            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6628            //   envelope_size bytes, there is always sufficient room.
6629            fidl::encoding::encode_in_envelope_optional::<GainProperties, D>(
6630                self.gain_properties
6631                    .as_ref()
6632                    .map(<GainProperties as fidl::encoding::ValueTypeMarker>::borrow),
6633                encoder,
6634                offset + cur_offset,
6635                depth,
6636            )?;
6637
6638            _prev_end_offset = cur_offset + envelope_size;
6639            if 5 > max_ordinal {
6640                return Ok(());
6641            }
6642
6643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6644            // are envelope_size bytes.
6645            let cur_offset: usize = (5 - 1) * envelope_size;
6646
6647            // Zero reserved fields.
6648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6649
6650            // Safety:
6651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6653            //   envelope_size bytes, there is always sufficient room.
6654            fidl::encoding::encode_in_envelope_optional::<PlugProperties, D>(
6655                self.plug_properties
6656                    .as_ref()
6657                    .map(<PlugProperties as fidl::encoding::ValueTypeMarker>::borrow),
6658                encoder,
6659                offset + cur_offset,
6660                depth,
6661            )?;
6662
6663            _prev_end_offset = cur_offset + envelope_size;
6664
6665            Ok(())
6666        }
6667    }
6668
6669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamConfig {
6670        #[inline(always)]
6671        fn new_empty() -> Self {
6672            Self::default()
6673        }
6674
6675        unsafe fn decode(
6676            &mut self,
6677            decoder: &mut fidl::encoding::Decoder<'_, D>,
6678            offset: usize,
6679            mut depth: fidl::encoding::Depth,
6680        ) -> fidl::Result<()> {
6681            decoder.debug_check_bounds::<Self>(offset);
6682            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6683                None => return Err(fidl::Error::NotNullable),
6684                Some(len) => len,
6685            };
6686            // Calling decoder.out_of_line_offset(0) is not allowed.
6687            if len == 0 {
6688                return Ok(());
6689            };
6690            depth.increment()?;
6691            let envelope_size = 8;
6692            let bytes_len = len * envelope_size;
6693            let offset = decoder.out_of_line_offset(bytes_len)?;
6694            // Decode the envelope for each type.
6695            let mut _next_ordinal_to_read = 0;
6696            let mut next_offset = offset;
6697            let end_offset = offset + bytes_len;
6698            _next_ordinal_to_read += 1;
6699            if next_offset >= end_offset {
6700                return Ok(());
6701            }
6702
6703            // Decode unknown envelopes for gaps in ordinals.
6704            while _next_ordinal_to_read < 1 {
6705                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6706                _next_ordinal_to_read += 1;
6707                next_offset += envelope_size;
6708            }
6709
6710            let next_out_of_line = decoder.next_out_of_line();
6711            let handles_before = decoder.remaining_handles();
6712            if let Some((inlined, num_bytes, num_handles)) =
6713                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6714            {
6715                let member_inline_size =
6716                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6717                if inlined != (member_inline_size <= 4) {
6718                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6719                }
6720                let inner_offset;
6721                let mut inner_depth = depth.clone();
6722                if inlined {
6723                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6724                    inner_offset = next_offset;
6725                } else {
6726                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6727                    inner_depth.increment()?;
6728                }
6729                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
6730                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6731                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6732                {
6733                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6734                }
6735                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6736                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6737                }
6738            }
6739
6740            next_offset += envelope_size;
6741            _next_ordinal_to_read += 1;
6742            if next_offset >= end_offset {
6743                return Ok(());
6744            }
6745
6746            // Decode unknown envelopes for gaps in ordinals.
6747            while _next_ordinal_to_read < 2 {
6748                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6749                _next_ordinal_to_read += 1;
6750                next_offset += envelope_size;
6751            }
6752
6753            let next_out_of_line = decoder.next_out_of_line();
6754            let handles_before = decoder.remaining_handles();
6755            if let Some((inlined, num_bytes, num_handles)) =
6756                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6757            {
6758                let member_inline_size =
6759                    <RingBuffer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6760                if inlined != (member_inline_size <= 4) {
6761                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6762                }
6763                let inner_offset;
6764                let mut inner_depth = depth.clone();
6765                if inlined {
6766                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6767                    inner_offset = next_offset;
6768                } else {
6769                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6770                    inner_depth.increment()?;
6771                }
6772                let val_ref =
6773                    self.ring_buffer.get_or_insert_with(|| fidl::new_empty!(RingBuffer, D));
6774                fidl::decode!(RingBuffer, D, val_ref, decoder, inner_offset, inner_depth)?;
6775                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6776                {
6777                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6778                }
6779                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6780                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6781                }
6782            }
6783
6784            next_offset += envelope_size;
6785            _next_ordinal_to_read += 1;
6786            if next_offset >= end_offset {
6787                return Ok(());
6788            }
6789
6790            // Decode unknown envelopes for gaps in ordinals.
6791            while _next_ordinal_to_read < 3 {
6792                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6793                _next_ordinal_to_read += 1;
6794                next_offset += envelope_size;
6795            }
6796
6797            let next_out_of_line = decoder.next_out_of_line();
6798            let handles_before = decoder.remaining_handles();
6799            if let Some((inlined, num_bytes, num_handles)) =
6800                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6801            {
6802                let member_inline_size =
6803                    <ClockProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6804                if inlined != (member_inline_size <= 4) {
6805                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6806                }
6807                let inner_offset;
6808                let mut inner_depth = depth.clone();
6809                if inlined {
6810                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6811                    inner_offset = next_offset;
6812                } else {
6813                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6814                    inner_depth.increment()?;
6815                }
6816                let val_ref = self
6817                    .clock_properties
6818                    .get_or_insert_with(|| fidl::new_empty!(ClockProperties, D));
6819                fidl::decode!(ClockProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
6820                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6821                {
6822                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6823                }
6824                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6825                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6826                }
6827            }
6828
6829            next_offset += envelope_size;
6830            _next_ordinal_to_read += 1;
6831            if next_offset >= end_offset {
6832                return Ok(());
6833            }
6834
6835            // Decode unknown envelopes for gaps in ordinals.
6836            while _next_ordinal_to_read < 4 {
6837                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6838                _next_ordinal_to_read += 1;
6839                next_offset += envelope_size;
6840            }
6841
6842            let next_out_of_line = decoder.next_out_of_line();
6843            let handles_before = decoder.remaining_handles();
6844            if let Some((inlined, num_bytes, num_handles)) =
6845                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6846            {
6847                let member_inline_size =
6848                    <GainProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6849                if inlined != (member_inline_size <= 4) {
6850                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6851                }
6852                let inner_offset;
6853                let mut inner_depth = depth.clone();
6854                if inlined {
6855                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6856                    inner_offset = next_offset;
6857                } else {
6858                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6859                    inner_depth.increment()?;
6860                }
6861                let val_ref =
6862                    self.gain_properties.get_or_insert_with(|| fidl::new_empty!(GainProperties, D));
6863                fidl::decode!(GainProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
6864                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6865                {
6866                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6867                }
6868                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6869                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6870                }
6871            }
6872
6873            next_offset += envelope_size;
6874            _next_ordinal_to_read += 1;
6875            if next_offset >= end_offset {
6876                return Ok(());
6877            }
6878
6879            // Decode unknown envelopes for gaps in ordinals.
6880            while _next_ordinal_to_read < 5 {
6881                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6882                _next_ordinal_to_read += 1;
6883                next_offset += envelope_size;
6884            }
6885
6886            let next_out_of_line = decoder.next_out_of_line();
6887            let handles_before = decoder.remaining_handles();
6888            if let Some((inlined, num_bytes, num_handles)) =
6889                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6890            {
6891                let member_inline_size =
6892                    <PlugProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6893                if inlined != (member_inline_size <= 4) {
6894                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6895                }
6896                let inner_offset;
6897                let mut inner_depth = depth.clone();
6898                if inlined {
6899                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6900                    inner_offset = next_offset;
6901                } else {
6902                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6903                    inner_depth.increment()?;
6904                }
6905                let val_ref =
6906                    self.plug_properties.get_or_insert_with(|| fidl::new_empty!(PlugProperties, D));
6907                fidl::decode!(PlugProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
6908                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6909                {
6910                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6911                }
6912                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6913                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6914                }
6915            }
6916
6917            next_offset += envelope_size;
6918
6919            // Decode the remaining unknown envelopes.
6920            while next_offset < end_offset {
6921                _next_ordinal_to_read += 1;
6922                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6923                next_offset += envelope_size;
6924            }
6925
6926            Ok(())
6927        }
6928    }
6929
6930    impl fidl::encoding::ValueTypeMarker for DeviceSpecific {
6931        type Borrowed<'a> = &'a Self;
6932        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6933            value
6934        }
6935    }
6936
6937    unsafe impl fidl::encoding::TypeMarker for DeviceSpecific {
6938        type Owned = Self;
6939
6940        #[inline(always)]
6941        fn inline_align(_context: fidl::encoding::Context) -> usize {
6942            8
6943        }
6944
6945        #[inline(always)]
6946        fn inline_size(_context: fidl::encoding::Context) -> usize {
6947            16
6948        }
6949    }
6950
6951    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceSpecific, D>
6952        for &DeviceSpecific
6953    {
6954        #[inline]
6955        unsafe fn encode(
6956            self,
6957            encoder: &mut fidl::encoding::Encoder<'_, D>,
6958            offset: usize,
6959            _depth: fidl::encoding::Depth,
6960        ) -> fidl::Result<()> {
6961            encoder.debug_check_bounds::<DeviceSpecific>(offset);
6962            encoder.write_num::<u64>(self.ordinal(), offset);
6963            match self {
6964                DeviceSpecific::StreamConfig(ref val) => {
6965                    fidl::encoding::encode_in_envelope::<StreamConfig, D>(
6966                        <StreamConfig as fidl::encoding::ValueTypeMarker>::borrow(val),
6967                        encoder,
6968                        offset + 8,
6969                        _depth,
6970                    )
6971                }
6972                DeviceSpecific::Dai(ref val) => fidl::encoding::encode_in_envelope::<Dai, D>(
6973                    <Dai as fidl::encoding::ValueTypeMarker>::borrow(val),
6974                    encoder,
6975                    offset + 8,
6976                    _depth,
6977                ),
6978                DeviceSpecific::Codec(ref val) => fidl::encoding::encode_in_envelope::<Codec, D>(
6979                    <Codec as fidl::encoding::ValueTypeMarker>::borrow(val),
6980                    encoder,
6981                    offset + 8,
6982                    _depth,
6983                ),
6984                DeviceSpecific::Composite(ref val) => {
6985                    fidl::encoding::encode_in_envelope::<Composite, D>(
6986                        <Composite as fidl::encoding::ValueTypeMarker>::borrow(val),
6987                        encoder,
6988                        offset + 8,
6989                        _depth,
6990                    )
6991                }
6992                DeviceSpecific::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6993            }
6994        }
6995    }
6996
6997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceSpecific {
6998        #[inline(always)]
6999        fn new_empty() -> Self {
7000            Self::__SourceBreaking { unknown_ordinal: 0 }
7001        }
7002
7003        #[inline]
7004        unsafe fn decode(
7005            &mut self,
7006            decoder: &mut fidl::encoding::Decoder<'_, D>,
7007            offset: usize,
7008            mut depth: fidl::encoding::Depth,
7009        ) -> fidl::Result<()> {
7010            decoder.debug_check_bounds::<Self>(offset);
7011            #[allow(unused_variables)]
7012            let next_out_of_line = decoder.next_out_of_line();
7013            let handles_before = decoder.remaining_handles();
7014            let (ordinal, inlined, num_bytes, num_handles) =
7015                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7016
7017            let member_inline_size = match ordinal {
7018                1 => <StreamConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7019                2 => <Dai as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7020                3 => <Codec as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7021                4 => <Composite as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7022                0 => return Err(fidl::Error::UnknownUnionTag),
7023                _ => num_bytes as usize,
7024            };
7025
7026            if inlined != (member_inline_size <= 4) {
7027                return Err(fidl::Error::InvalidInlineBitInEnvelope);
7028            }
7029            let _inner_offset;
7030            if inlined {
7031                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7032                _inner_offset = offset + 8;
7033            } else {
7034                depth.increment()?;
7035                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7036            }
7037            match ordinal {
7038                1 => {
7039                    #[allow(irrefutable_let_patterns)]
7040                    if let DeviceSpecific::StreamConfig(_) = self {
7041                        // Do nothing, read the value into the object
7042                    } else {
7043                        // Initialize `self` to the right variant
7044                        *self = DeviceSpecific::StreamConfig(fidl::new_empty!(StreamConfig, D));
7045                    }
7046                    #[allow(irrefutable_let_patterns)]
7047                    if let DeviceSpecific::StreamConfig(ref mut val) = self {
7048                        fidl::decode!(StreamConfig, D, val, decoder, _inner_offset, depth)?;
7049                    } else {
7050                        unreachable!()
7051                    }
7052                }
7053                2 => {
7054                    #[allow(irrefutable_let_patterns)]
7055                    if let DeviceSpecific::Dai(_) = self {
7056                        // Do nothing, read the value into the object
7057                    } else {
7058                        // Initialize `self` to the right variant
7059                        *self = DeviceSpecific::Dai(fidl::new_empty!(Dai, D));
7060                    }
7061                    #[allow(irrefutable_let_patterns)]
7062                    if let DeviceSpecific::Dai(ref mut val) = self {
7063                        fidl::decode!(Dai, D, val, decoder, _inner_offset, depth)?;
7064                    } else {
7065                        unreachable!()
7066                    }
7067                }
7068                3 => {
7069                    #[allow(irrefutable_let_patterns)]
7070                    if let DeviceSpecific::Codec(_) = self {
7071                        // Do nothing, read the value into the object
7072                    } else {
7073                        // Initialize `self` to the right variant
7074                        *self = DeviceSpecific::Codec(fidl::new_empty!(Codec, D));
7075                    }
7076                    #[allow(irrefutable_let_patterns)]
7077                    if let DeviceSpecific::Codec(ref mut val) = self {
7078                        fidl::decode!(Codec, D, val, decoder, _inner_offset, depth)?;
7079                    } else {
7080                        unreachable!()
7081                    }
7082                }
7083                4 => {
7084                    #[allow(irrefutable_let_patterns)]
7085                    if let DeviceSpecific::Composite(_) = self {
7086                        // Do nothing, read the value into the object
7087                    } else {
7088                        // Initialize `self` to the right variant
7089                        *self = DeviceSpecific::Composite(fidl::new_empty!(Composite, D));
7090                    }
7091                    #[allow(irrefutable_let_patterns)]
7092                    if let DeviceSpecific::Composite(ref mut val) = self {
7093                        fidl::decode!(Composite, D, val, decoder, _inner_offset, depth)?;
7094                    } else {
7095                        unreachable!()
7096                    }
7097                }
7098                #[allow(deprecated)]
7099                ordinal => {
7100                    for _ in 0..num_handles {
7101                        decoder.drop_next_handle()?;
7102                    }
7103                    *self = DeviceSpecific::__SourceBreaking { unknown_ordinal: ordinal };
7104                }
7105            }
7106            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7107                return Err(fidl::Error::InvalidNumBytesInEnvelope);
7108            }
7109            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7110                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7111            }
7112            Ok(())
7113        }
7114    }
7115}