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