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