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