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 type CompressionType = String;
13
14pub type EncryptionScheme = String;
15
16pub type InitVector = Vec<u8>;
17
18pub type KeyId = Vec<u8>;
19
20pub const AUDIO_ENCODING_AAC: &str = "fuchsia.media.aac";
22
23pub const AUDIO_ENCODING_AACLATM: &str = "fuchsia.media.aaclatm";
24
25pub const AUDIO_ENCODING_AMRNB: &str = "fuchsia.media.amrnb";
26
27pub const AUDIO_ENCODING_AMRWB: &str = "fuchsia.media.amrwb";
28
29pub const AUDIO_ENCODING_APTX: &str = "fuchsia.media.aptx";
30
31pub const AUDIO_ENCODING_FLAC: &str = "fuchsia.media.flac";
32
33pub const AUDIO_ENCODING_GSMMS: &str = "fuchsia.media.gsmms";
34
35pub const AUDIO_ENCODING_LPCM: &str = "fuchsia.media.lpcm";
36
37pub const AUDIO_ENCODING_MP3: &str = "fuchsia.media.mp3";
38
39pub const AUDIO_ENCODING_OPUS: &str = "fuchsia.media.opus";
40
41pub const AUDIO_ENCODING_PCMALAW: &str = "fuchsia.media.pcmalaw";
42
43pub const AUDIO_ENCODING_PCMMULAW: &str = "fuchsia.media.pcmmulaw";
44
45pub const AUDIO_ENCODING_SBC: &str = "fuchsia.media.sbc";
46
47pub const AUDIO_ENCODING_VORBIS: &str = "fuchsia.media.vorbis";
48
49pub const CAPTURE_USAGE2_COUNT: u8 = 4;
50
51pub const CAPTURE_USAGE_COUNT: u8 = 4;
52
53pub const ENCRYPTION_SCHEME_CBC1: &str = "cbc1";
54
55pub const ENCRYPTION_SCHEME_CBCS: &str = "cbcs";
56
57pub const ENCRYPTION_SCHEME_CENC: &str = "cenc";
58
59pub const ENCRYPTION_SCHEME_CENS: &str = "cens";
60
61pub const ENCRYPTION_SCHEME_UNENCRYPTED: &str = "unencrypted";
62
63pub const MAX_ENCRYPTION_SCHEME_SIZE: u32 = 100;
64
65pub const MAX_FRAMES_PER_RENDERER_PACKET: i64 = 262143;
67
68pub const MAX_INIT_VECTOR_SIZE: u32 = 16;
69
70pub const MAX_KEY_ID_SIZE: u32 = 16;
71
72pub const MAX_PCM_CHANNEL_COUNT: u32 = 8;
73
74pub const MAX_PCM_FRAMES_PER_SECOND: u32 = 192000;
75
76pub const MAX_USAGE_COUNT: u8 = 8;
80
81pub const METADATA_LABEL_ALBUM: &str = "fuchsia.media.album";
82
83pub const METADATA_LABEL_ARTIST: &str = "fuchsia.media.artist";
84
85pub const METADATA_LABEL_COMPOSER: &str = "fuchsia.media.composer";
86
87pub const METADATA_LABEL_EPISODE: &str = "fuchsia.media.episode";
88
89pub const METADATA_LABEL_GENRE: &str = "fuchsia.media.genre";
90
91pub const METADATA_LABEL_PUBLISHER: &str = "fuchsia.media.publisher";
92
93pub const METADATA_LABEL_RELEASE_DATE: &str = "fuchsia.media.release_date";
94
95pub const METADATA_LABEL_SEASON: &str = "fuchsia.media.season";
96
97pub const METADATA_LABEL_STUDIO: &str = "fuchsia.media.studio";
98
99pub const METADATA_LABEL_SUBTITLE: &str = "fuchsia.media.subtitle";
100
101pub const METADATA_LABEL_TITLE: &str = "fuchsia.media.title";
102
103pub const METADATA_LABEL_TRACK_NUMBER: &str = "fuchsia.media.track_number";
104
105pub const METADATA_SOURCE_TITLE: &str = "fuchsia.media.source_title";
108
109pub const MIN_PCM_CHANNEL_COUNT: u32 = 1;
111
112pub const MIN_PCM_FRAMES_PER_SECOND: u32 = 1000;
113
114pub const NO_TIMESTAMP: i64 = 9223372036854775807;
118
119pub const RENDER_USAGE2_COUNT: u8 = 6;
120
121pub const RENDER_USAGE_COUNT: u8 = 5;
122
123pub const STREAM_PACKET_FLAG_DISCONTINUITY: u32 = 4;
127
128pub const STREAM_PACKET_FLAG_DROPPABLE: u32 = 2;
133
134pub const STREAM_PACKET_FLAG_KEY_FRAME: u32 = 1;
138
139pub const VIDEO_ENCODING_H263: &str = "fuchsia.media.h263";
141
142pub const VIDEO_ENCODING_H264: &str = "fuchsia.media.h264";
143
144pub const VIDEO_ENCODING_MPEG4: &str = "fuchsia.media.mpeg4";
145
146pub const VIDEO_ENCODING_THEORA: &str = "fuchsia.media.theora";
147
148pub const VIDEO_ENCODING_UNCOMPRESSED: &str = "fuchsia.media.uncompressed_video";
149
150pub const VIDEO_ENCODING_VP3: &str = "fuchsia.media.vp3";
151
152pub const VIDEO_ENCODING_VP8: &str = "fuchsia.media.vp8";
153
154pub const VIDEO_ENCODING_VP9: &str = "fuchsia.media.vp9";
155
156pub const MAX_OOB_BYTES_SIZE: u64 = 8192;
157
158bitflags! {
159 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
161 pub struct AudioConsumerStartFlags: u32 {
162 const LOW_LATENCY = 1;
164 const SUPPLY_DRIVEN = 2;
169 }
170}
171
172impl AudioConsumerStartFlags {}
173
174bitflags! {
175 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
176 pub struct AudioGainInfoFlags: u32 {
177 const MUTE = 1;
178 const AGC_SUPPORTED = 2;
179 const AGC_ENABLED = 4;
180 }
181}
182
183impl AudioGainInfoFlags {}
184
185bitflags! {
186 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
187 pub struct AudioGainValidFlags: u32 {
188 const GAIN_VALID = 1;
189 const MUTE_VALID = 2;
190 const AGC_VALID = 4;
191 }
192}
193
194impl AudioGainValidFlags {}
195
196#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
197#[repr(u32)]
198pub enum AacAudioObjectType {
199 Mpeg2AacLc = 0,
201 Mpeg4AacLc = 1,
203}
204
205impl AacAudioObjectType {
206 #[inline]
207 pub fn from_primitive(prim: u32) -> Option<Self> {
208 match prim {
209 0 => Some(Self::Mpeg2AacLc),
210 1 => Some(Self::Mpeg4AacLc),
211 _ => None,
212 }
213 }
214
215 #[inline]
216 pub const fn into_primitive(self) -> u32 {
217 self as u32
218 }
219}
220
221#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
222#[repr(u32)]
223pub enum AacChannelMode {
224 Mono = 0,
225 Stereo = 2,
226}
227
228impl AacChannelMode {
229 #[inline]
230 pub fn from_primitive(prim: u32) -> Option<Self> {
231 match prim {
232 0 => Some(Self::Mono),
233 2 => Some(Self::Stereo),
234 _ => None,
235 }
236 }
237
238 #[inline]
239 pub const fn into_primitive(self) -> u32 {
240 self as u32
241 }
242}
243
244#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
249#[repr(u32)]
250pub enum AacVariableBitRate {
251 V1 = 1,
252 V2 = 2,
253 V3 = 3,
254 V4 = 4,
255 V5 = 5,
256}
257
258impl AacVariableBitRate {
259 #[inline]
260 pub fn from_primitive(prim: u32) -> Option<Self> {
261 match prim {
262 1 => Some(Self::V1),
263 2 => Some(Self::V2),
264 3 => Some(Self::V3),
265 4 => Some(Self::V4),
266 5 => Some(Self::V5),
267 _ => None,
268 }
269 }
270
271 #[inline]
272 pub const fn into_primitive(self) -> u32 {
273 self as u32
274 }
275}
276
277#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
278#[repr(u32)]
279pub enum AudioBitrateMode {
280 Unspecified = 0,
281 Cbr = 1,
282 Vbr = 2,
283}
284
285impl AudioBitrateMode {
286 #[inline]
287 pub fn from_primitive(prim: u32) -> Option<Self> {
288 match prim {
289 0 => Some(Self::Unspecified),
290 1 => Some(Self::Cbr),
291 2 => Some(Self::Vbr),
292 _ => None,
293 }
294 }
295
296 #[inline]
297 pub const fn into_primitive(self) -> u32 {
298 self as u32
299 }
300}
301
302#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
306#[repr(u32)]
307pub enum AudioCaptureUsage {
308 Background = 0,
312 Foreground = 1,
317 SystemAgent = 2,
322 Communication = 3,
325}
326
327impl AudioCaptureUsage {
328 #[inline]
329 pub fn from_primitive(prim: u32) -> Option<Self> {
330 match prim {
331 0 => Some(Self::Background),
332 1 => Some(Self::Foreground),
333 2 => Some(Self::SystemAgent),
334 3 => Some(Self::Communication),
335 _ => None,
336 }
337 }
338
339 #[inline]
340 pub const fn into_primitive(self) -> u32 {
341 self as u32
342 }
343}
344
345#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
349pub enum AudioCaptureUsage2 {
350 Background,
354 Foreground,
358 SystemAgent,
362 Communication,
365 #[doc(hidden)]
366 __SourceBreaking { unknown_ordinal: u32 },
367}
368
369#[macro_export]
371macro_rules! AudioCaptureUsage2Unknown {
372 () => {
373 _
374 };
375}
376
377impl AudioCaptureUsage2 {
378 #[inline]
379 pub fn from_primitive(prim: u32) -> Option<Self> {
380 match prim {
381 0 => Some(Self::Background),
382 1 => Some(Self::Foreground),
383 2 => Some(Self::SystemAgent),
384 3 => Some(Self::Communication),
385 _ => None,
386 }
387 }
388
389 #[inline]
390 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
391 match prim {
392 0 => Self::Background,
393 1 => Self::Foreground,
394 2 => Self::SystemAgent,
395 3 => Self::Communication,
396 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
397 }
398 }
399
400 #[inline]
401 pub fn unknown() -> Self {
402 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
403 }
404
405 #[inline]
406 pub const fn into_primitive(self) -> u32 {
407 match self {
408 Self::Background => 0,
409 Self::Foreground => 1,
410 Self::SystemAgent => 2,
411 Self::Communication => 3,
412 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
413 }
414 }
415
416 #[inline]
417 pub fn is_unknown(&self) -> bool {
418 match self {
419 Self::__SourceBreaking { unknown_ordinal: _ } => true,
420 _ => false,
421 }
422 }
423}
424
425#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
431#[repr(u32)]
432pub enum AudioChannelId {
433 Skip = 0,
434 Lf = 1,
435 Rf = 2,
436 Cf = 3,
437 Ls = 4,
438 Rs = 5,
439 Lfe = 6,
440 Cs = 7,
441 Lr = 8,
442 Rr = 9,
443 EndDefined = 10,
444 ExtendedChannelIdBase = 1862270976,
445 Max = 2147483647,
446}
447
448impl AudioChannelId {
449 #[inline]
450 pub fn from_primitive(prim: u32) -> Option<Self> {
451 match prim {
452 0 => Some(Self::Skip),
453 1 => Some(Self::Lf),
454 2 => Some(Self::Rf),
455 3 => Some(Self::Cf),
456 4 => Some(Self::Ls),
457 5 => Some(Self::Rs),
458 6 => Some(Self::Lfe),
459 7 => Some(Self::Cs),
460 8 => Some(Self::Lr),
461 9 => Some(Self::Rr),
462 10 => Some(Self::EndDefined),
463 1862270976 => Some(Self::ExtendedChannelIdBase),
464 2147483647 => Some(Self::Max),
465 _ => None,
466 }
467 }
468
469 #[inline]
470 pub const fn into_primitive(self) -> u32 {
471 self as u32
472 }
473}
474
475#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
476#[repr(u32)]
477pub enum AudioOutputRoutingPolicy {
478 AllPluggedOutputs = 0,
479 LastPluggedOutput = 1,
480}
481
482impl AudioOutputRoutingPolicy {
483 #[inline]
484 pub fn from_primitive(prim: u32) -> Option<Self> {
485 match prim {
486 0 => Some(Self::AllPluggedOutputs),
487 1 => Some(Self::LastPluggedOutput),
488 _ => None,
489 }
490 }
491
492 #[inline]
493 pub const fn into_primitive(self) -> u32 {
494 self as u32
495 }
496}
497
498#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
500#[repr(u32)]
501pub enum AudioPcmMode {
502 Linear = 0,
503 Alaw = 1,
504 Mulaw = 2,
505}
506
507impl AudioPcmMode {
508 #[inline]
509 pub fn from_primitive(prim: u32) -> Option<Self> {
510 match prim {
511 0 => Some(Self::Linear),
512 1 => Some(Self::Alaw),
513 2 => Some(Self::Mulaw),
514 _ => None,
515 }
516 }
517
518 #[inline]
519 pub const fn into_primitive(self) -> u32 {
520 self as u32
521 }
522}
523
524#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
529#[repr(u32)]
530pub enum AudioRenderUsage {
531 Background = 0,
534 Media = 1,
537 Interruption = 2,
541 SystemAgent = 3,
544 Communication = 4,
547}
548
549impl AudioRenderUsage {
550 #[inline]
551 pub fn from_primitive(prim: u32) -> Option<Self> {
552 match prim {
553 0 => Some(Self::Background),
554 1 => Some(Self::Media),
555 2 => Some(Self::Interruption),
556 3 => Some(Self::SystemAgent),
557 4 => Some(Self::Communication),
558 _ => None,
559 }
560 }
561
562 #[inline]
563 pub const fn into_primitive(self) -> u32 {
564 self as u32
565 }
566}
567
568#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
573pub enum AudioRenderUsage2 {
574 Background,
577 Media,
580 Interruption,
584 SystemAgent,
587 Communication,
590 Accessibility,
593 #[doc(hidden)]
594 __SourceBreaking { unknown_ordinal: u32 },
595}
596
597#[macro_export]
599macro_rules! AudioRenderUsage2Unknown {
600 () => {
601 _
602 };
603}
604
605impl AudioRenderUsage2 {
606 #[inline]
607 pub fn from_primitive(prim: u32) -> Option<Self> {
608 match prim {
609 0 => Some(Self::Background),
610 1 => Some(Self::Media),
611 2 => Some(Self::Interruption),
612 3 => Some(Self::SystemAgent),
613 4 => Some(Self::Communication),
614 5 => Some(Self::Accessibility),
615 _ => None,
616 }
617 }
618
619 #[inline]
620 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
621 match prim {
622 0 => Self::Background,
623 1 => Self::Media,
624 2 => Self::Interruption,
625 3 => Self::SystemAgent,
626 4 => Self::Communication,
627 5 => Self::Accessibility,
628 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
629 }
630 }
631
632 #[inline]
633 pub fn unknown() -> Self {
634 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
635 }
636
637 #[inline]
638 pub const fn into_primitive(self) -> u32 {
639 match self {
640 Self::Background => 0,
641 Self::Media => 1,
642 Self::Interruption => 2,
643 Self::SystemAgent => 3,
644 Self::Communication => 4,
645 Self::Accessibility => 5,
646 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
647 }
648 }
649
650 #[inline]
651 pub fn is_unknown(&self) -> bool {
652 match self {
653 Self::__SourceBreaking { unknown_ordinal: _ } => true,
654 _ => false,
655 }
656 }
657}
658
659#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
661#[repr(u32)]
662pub enum AudioSampleFormat {
663 Unsigned8 = 1,
665 Signed16 = 2,
667 Signed24In32 = 3,
669 Float = 4,
671}
672
673impl AudioSampleFormat {
674 #[inline]
675 pub fn from_primitive(prim: u32) -> Option<Self> {
676 match prim {
677 1 => Some(Self::Unsigned8),
678 2 => Some(Self::Signed16),
679 3 => Some(Self::Signed24In32),
680 4 => Some(Self::Float),
681 _ => None,
682 }
683 }
684
685 #[inline]
686 pub const fn into_primitive(self) -> u32 {
687 self as u32
688 }
689}
690
691#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
692pub enum Behavior {
693 None,
695 Duck,
697 Mute,
699 #[doc(hidden)]
700 __SourceBreaking { unknown_ordinal: u32 },
701}
702
703#[macro_export]
705macro_rules! BehaviorUnknown {
706 () => {
707 _
708 };
709}
710
711impl Behavior {
712 #[inline]
713 pub fn from_primitive(prim: u32) -> Option<Self> {
714 match prim {
715 0 => Some(Self::None),
716 1 => Some(Self::Duck),
717 2 => Some(Self::Mute),
718 _ => None,
719 }
720 }
721
722 #[inline]
723 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
724 match prim {
725 0 => Self::None,
726 1 => Self::Duck,
727 2 => Self::Mute,
728 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
729 }
730 }
731
732 #[inline]
733 pub fn unknown() -> Self {
734 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
735 }
736
737 #[inline]
738 pub const fn into_primitive(self) -> u32 {
739 match self {
740 Self::None => 0,
741 Self::Duck => 1,
742 Self::Mute => 2,
743 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
744 }
745 }
746
747 #[inline]
748 pub fn is_unknown(&self) -> bool {
749 match self {
750 Self::__SourceBreaking { unknown_ordinal: _ } => true,
751 _ => false,
752 }
753 }
754}
755
756#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
759pub enum CodecProfile {
760 H264ProfileBaseline,
761 H264ProfileMain,
762 H264ProfileExtended,
763 H264ProfileHigh,
764 H264ProfileHigh10Profile,
765 H264ProfileHigh422Profile,
766 H264ProfileHigh444Predictiveprofile,
767 H264ProfileScalablebaseline,
768 H264ProfileScalablehigh,
769 H264ProfileStereohigh,
770 H264ProfileMultiviewhigh,
771 Vp8ProfileAny,
772 Vp9ProfileProfile0,
773 Vp9ProfileProfile1,
774 Vp9ProfileProfile2,
775 Vp9ProfileProfile3,
776 HevcprofileMain,
777 HevcprofileMain10,
778 HevcprofileMainStillPicture,
779 MjpegBaseline,
780 #[doc(hidden)]
781 __SourceBreaking {
782 unknown_ordinal: u32,
783 },
784}
785
786#[macro_export]
788macro_rules! CodecProfileUnknown {
789 () => {
790 _
791 };
792}
793
794impl CodecProfile {
795 #[inline]
796 pub fn from_primitive(prim: u32) -> Option<Self> {
797 match prim {
798 0 => Some(Self::H264ProfileBaseline),
799 1 => Some(Self::H264ProfileMain),
800 2 => Some(Self::H264ProfileExtended),
801 3 => Some(Self::H264ProfileHigh),
802 4 => Some(Self::H264ProfileHigh10Profile),
803 5 => Some(Self::H264ProfileHigh422Profile),
804 6 => Some(Self::H264ProfileHigh444Predictiveprofile),
805 7 => Some(Self::H264ProfileScalablebaseline),
806 8 => Some(Self::H264ProfileScalablehigh),
807 9 => Some(Self::H264ProfileStereohigh),
808 10 => Some(Self::H264ProfileMultiviewhigh),
809 11 => Some(Self::Vp8ProfileAny),
810 12 => Some(Self::Vp9ProfileProfile0),
811 13 => Some(Self::Vp9ProfileProfile1),
812 14 => Some(Self::Vp9ProfileProfile2),
813 15 => Some(Self::Vp9ProfileProfile3),
814 16 => Some(Self::HevcprofileMain),
815 17 => Some(Self::HevcprofileMain10),
816 18 => Some(Self::HevcprofileMainStillPicture),
817 19 => Some(Self::MjpegBaseline),
818 _ => None,
819 }
820 }
821
822 #[inline]
823 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
824 match prim {
825 0 => Self::H264ProfileBaseline,
826 1 => Self::H264ProfileMain,
827 2 => Self::H264ProfileExtended,
828 3 => Self::H264ProfileHigh,
829 4 => Self::H264ProfileHigh10Profile,
830 5 => Self::H264ProfileHigh422Profile,
831 6 => Self::H264ProfileHigh444Predictiveprofile,
832 7 => Self::H264ProfileScalablebaseline,
833 8 => Self::H264ProfileScalablehigh,
834 9 => Self::H264ProfileStereohigh,
835 10 => Self::H264ProfileMultiviewhigh,
836 11 => Self::Vp8ProfileAny,
837 12 => Self::Vp9ProfileProfile0,
838 13 => Self::Vp9ProfileProfile1,
839 14 => Self::Vp9ProfileProfile2,
840 15 => Self::Vp9ProfileProfile3,
841 16 => Self::HevcprofileMain,
842 17 => Self::HevcprofileMain10,
843 18 => Self::HevcprofileMainStillPicture,
844 19 => Self::MjpegBaseline,
845 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
846 }
847 }
848
849 #[inline]
850 pub fn unknown() -> Self {
851 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
852 }
853
854 #[inline]
855 pub const fn into_primitive(self) -> u32 {
856 match self {
857 Self::H264ProfileBaseline => 0,
858 Self::H264ProfileMain => 1,
859 Self::H264ProfileExtended => 2,
860 Self::H264ProfileHigh => 3,
861 Self::H264ProfileHigh10Profile => 4,
862 Self::H264ProfileHigh422Profile => 5,
863 Self::H264ProfileHigh444Predictiveprofile => 6,
864 Self::H264ProfileScalablebaseline => 7,
865 Self::H264ProfileScalablehigh => 8,
866 Self::H264ProfileStereohigh => 9,
867 Self::H264ProfileMultiviewhigh => 10,
868 Self::Vp8ProfileAny => 11,
869 Self::Vp9ProfileProfile0 => 12,
870 Self::Vp9ProfileProfile1 => 13,
871 Self::Vp9ProfileProfile2 => 14,
872 Self::Vp9ProfileProfile3 => 15,
873 Self::HevcprofileMain => 16,
874 Self::HevcprofileMain10 => 17,
875 Self::HevcprofileMainStillPicture => 18,
876 Self::MjpegBaseline => 19,
877 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
878 }
879 }
880
881 #[inline]
882 pub fn is_unknown(&self) -> bool {
883 match self {
884 Self::__SourceBreaking { unknown_ordinal: _ } => true,
885 _ => false,
886 }
887 }
888}
889
890#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
891#[repr(u32)]
892pub enum ColorSpace {
893 Unknown = 0,
894 NotApplicable = 1,
895 Jpeg = 2,
896 HdRec709 = 3,
897 SdRec601 = 4,
898}
899
900impl ColorSpace {
901 #[inline]
902 pub fn from_primitive(prim: u32) -> Option<Self> {
903 match prim {
904 0 => Some(Self::Unknown),
905 1 => Some(Self::NotApplicable),
906 2 => Some(Self::Jpeg),
907 3 => Some(Self::HdRec709),
908 4 => Some(Self::SdRec601),
909 _ => None,
910 }
911 }
912
913 #[inline]
914 pub const fn into_primitive(self) -> u32 {
915 self as u32
916 }
917}
918
919#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
920pub enum Lc3FrameDuration {
921 D10Ms,
922 D7P5Ms,
923 #[doc(hidden)]
924 __SourceBreaking {
925 unknown_ordinal: u32,
926 },
927}
928
929#[macro_export]
931macro_rules! Lc3FrameDurationUnknown {
932 () => {
933 _
934 };
935}
936
937impl Lc3FrameDuration {
938 #[inline]
939 pub fn from_primitive(prim: u32) -> Option<Self> {
940 match prim {
941 1 => Some(Self::D10Ms),
942 2 => Some(Self::D7P5Ms),
943 _ => None,
944 }
945 }
946
947 #[inline]
948 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
949 match prim {
950 1 => Self::D10Ms,
951 2 => Self::D7P5Ms,
952 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
953 }
954 }
955
956 #[inline]
957 pub fn unknown() -> Self {
958 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
959 }
960
961 #[inline]
962 pub const fn into_primitive(self) -> u32 {
963 match self {
964 Self::D10Ms => 1,
965 Self::D7P5Ms => 2,
966 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
967 }
968 }
969
970 #[inline]
971 pub fn is_unknown(&self) -> bool {
972 match self {
973 Self::__SourceBreaking { unknown_ordinal: _ } => true,
974 _ => false,
975 }
976 }
977}
978
979#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
980#[repr(u32)]
981pub enum SbcAllocation {
982 AllocLoudness = 0,
983 AllocSnr = 1,
984}
985
986impl SbcAllocation {
987 #[inline]
988 pub fn from_primitive(prim: u32) -> Option<Self> {
989 match prim {
990 0 => Some(Self::AllocLoudness),
991 1 => Some(Self::AllocSnr),
992 _ => None,
993 }
994 }
995
996 #[inline]
997 pub const fn into_primitive(self) -> u32 {
998 self as u32
999 }
1000}
1001
1002#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1003#[repr(u32)]
1004pub enum SbcBlockCount {
1005 BlockCount4 = 4,
1006 BlockCount8 = 8,
1007 BlockCount12 = 12,
1008 BlockCount16 = 16,
1009}
1010
1011impl SbcBlockCount {
1012 #[inline]
1013 pub fn from_primitive(prim: u32) -> Option<Self> {
1014 match prim {
1015 4 => Some(Self::BlockCount4),
1016 8 => Some(Self::BlockCount8),
1017 12 => Some(Self::BlockCount12),
1018 16 => Some(Self::BlockCount16),
1019 _ => None,
1020 }
1021 }
1022
1023 #[inline]
1024 pub const fn into_primitive(self) -> u32 {
1025 self as u32
1026 }
1027}
1028
1029#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1030#[repr(u32)]
1031pub enum SbcChannelMode {
1032 Mono = 0,
1033 Dual = 1,
1034 Stereo = 2,
1035 JointStereo = 3,
1036}
1037
1038impl SbcChannelMode {
1039 #[inline]
1040 pub fn from_primitive(prim: u32) -> Option<Self> {
1041 match prim {
1042 0 => Some(Self::Mono),
1043 1 => Some(Self::Dual),
1044 2 => Some(Self::Stereo),
1045 3 => Some(Self::JointStereo),
1046 _ => None,
1047 }
1048 }
1049
1050 #[inline]
1051 pub const fn into_primitive(self) -> u32 {
1052 self as u32
1053 }
1054}
1055
1056#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1057#[repr(u32)]
1058pub enum SbcSubBands {
1059 SubBands4 = 4,
1060 SubBands8 = 8,
1061}
1062
1063impl SbcSubBands {
1064 #[inline]
1065 pub fn from_primitive(prim: u32) -> Option<Self> {
1066 match prim {
1067 4 => Some(Self::SubBands4),
1068 8 => Some(Self::SubBands8),
1069 _ => None,
1070 }
1071 }
1072
1073 #[inline]
1074 pub const fn into_primitive(self) -> u32 {
1075 self as u32
1076 }
1077}
1078
1079#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1085#[repr(u32)]
1086pub enum StreamError {
1087 Unknown = 1,
1089 InvalidInputFormatDetails = 2,
1091 IncompatibleBuffersProvided = 3,
1095 EosProcessing = 4,
1099 DecoderUnknown = 16777217,
1101 DecoderDataParsing = 16777218,
1105 EncoderUnknown = 33554433,
1107 DecryptorUnknown = 50331649,
1109 DecryptorNoKey = 50331650,
1112}
1113
1114impl StreamError {
1115 #[inline]
1116 pub fn from_primitive(prim: u32) -> Option<Self> {
1117 match prim {
1118 1 => Some(Self::Unknown),
1119 2 => Some(Self::InvalidInputFormatDetails),
1120 3 => Some(Self::IncompatibleBuffersProvided),
1121 4 => Some(Self::EosProcessing),
1122 16777217 => Some(Self::DecoderUnknown),
1123 16777218 => Some(Self::DecoderDataParsing),
1124 33554433 => Some(Self::EncoderUnknown),
1125 50331649 => Some(Self::DecryptorUnknown),
1126 50331650 => Some(Self::DecryptorNoKey),
1127 _ => None,
1128 }
1129 }
1130
1131 #[inline]
1132 pub const fn into_primitive(self) -> u32 {
1133 self as u32
1134 }
1135}
1136
1137#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1138#[repr(u32)]
1139pub enum VideoColorSpace {
1140 Invalid = 0,
1141}
1142
1143impl VideoColorSpace {
1144 #[inline]
1145 pub fn from_primitive(prim: u32) -> Option<Self> {
1146 match prim {
1147 0 => Some(Self::Invalid),
1148 _ => None,
1149 }
1150 }
1151
1152 #[inline]
1153 pub const fn into_primitive(self) -> u32 {
1154 self as u32
1155 }
1156}
1157
1158#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1159#[repr(C)]
1160pub struct AacConstantBitRate {
1161 pub bit_rate: u32,
1163}
1164
1165impl fidl::Persistable for AacConstantBitRate {}
1166
1167#[derive(Clone, Debug, PartialEq)]
1168pub struct AacEncoderSettings {
1169 pub transport: AacTransport,
1170 pub channel_mode: AacChannelMode,
1171 pub bit_rate: AacBitRate,
1172 pub aot: AacAudioObjectType,
1173}
1174
1175impl fidl::Persistable for AacEncoderSettings {}
1176
1177#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1179pub struct AacTransportAdts;
1180
1181impl fidl::Persistable for AacTransportAdts {}
1182
1183#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1185pub struct AacTransportLatm {
1186 pub mux_config_present: bool,
1188}
1189
1190impl fidl::Persistable for AacTransportLatm {}
1191
1192#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1194pub struct AacTransportRaw;
1195
1196impl fidl::Persistable for AacTransportRaw {}
1197
1198#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1199pub struct ActivityReporterWatchCaptureActivityResponse {
1200 pub active_usages: Vec<AudioCaptureUsage>,
1201}
1202
1203impl fidl::Persistable for ActivityReporterWatchCaptureActivityResponse {}
1204
1205#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1206pub struct ActivityReporterWatchRenderActivityResponse {
1207 pub active_usages: Vec<AudioRenderUsage>,
1208}
1209
1210impl fidl::Persistable for ActivityReporterWatchRenderActivityResponse {}
1211
1212#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1213pub struct ActivityReporterWatchCaptureActivity2Response {
1214 pub active_usages: Vec<AudioCaptureUsage2>,
1215}
1216
1217impl fidl::Persistable for ActivityReporterWatchCaptureActivity2Response {}
1218
1219#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1220pub struct ActivityReporterWatchRenderActivity2Response {
1221 pub active_usages: Vec<AudioRenderUsage2>,
1222}
1223
1224impl fidl::Persistable for ActivityReporterWatchRenderActivity2Response {}
1225
1226#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1227#[repr(C)]
1228pub struct AudioCapturerCaptureAtRequest {
1229 pub payload_buffer_id: u32,
1230 pub payload_offset: u32,
1231 pub frames: u32,
1232}
1233
1234impl fidl::Persistable for AudioCapturerCaptureAtRequest {}
1235
1236#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1237#[repr(C)]
1238pub struct AudioCapturerCaptureAtResponse {
1239 pub captured_packet: StreamPacket,
1240}
1241
1242impl fidl::Persistable for AudioCapturerCaptureAtResponse {}
1243
1244#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1245pub struct AudioCapturerGetStreamTypeResponse {
1246 pub stream_type: StreamType,
1247}
1248
1249impl fidl::Persistable for AudioCapturerGetStreamTypeResponse {}
1250
1251#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1252pub struct AudioCapturerSetPcmStreamTypeRequest {
1253 pub stream_type: AudioStreamType,
1254}
1255
1256impl fidl::Persistable for AudioCapturerSetPcmStreamTypeRequest {}
1257
1258#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1259pub struct AudioCapturerSetUsage2Request {
1260 pub usage: AudioCaptureUsage2,
1261}
1262
1263impl fidl::Persistable for AudioCapturerSetUsage2Request {}
1264
1265#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1266pub struct AudioCapturerSetUsageRequest {
1267 pub usage: AudioCaptureUsage,
1268}
1269
1270impl fidl::Persistable for AudioCapturerSetUsageRequest {}
1271
1272#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1273#[repr(C)]
1274pub struct AudioCapturerStartAsyncCaptureRequest {
1275 pub frames_per_packet: u32,
1276}
1277
1278impl fidl::Persistable for AudioCapturerStartAsyncCaptureRequest {}
1279
1280#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1281pub struct AudioCompressedFormatAac;
1282
1283impl fidl::Persistable for AudioCompressedFormatAac {}
1284
1285#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1286pub struct AudioCompressedFormatSbc;
1287
1288impl fidl::Persistable for AudioCompressedFormatSbc {}
1289
1290#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1291pub struct AudioConsumerSetRateRequest {
1292 pub rate: f32,
1293}
1294
1295impl fidl::Persistable for AudioConsumerSetRateRequest {}
1296
1297#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1298pub struct AudioConsumerStartRequest {
1299 pub flags: AudioConsumerStartFlags,
1300 pub reference_time: i64,
1301 pub media_time: i64,
1302}
1303
1304impl fidl::Persistable for AudioConsumerStartRequest {}
1305
1306#[derive(Clone, Debug, PartialEq)]
1307pub struct AudioConsumerWatchStatusResponse {
1308 pub status: AudioConsumerStatus,
1309}
1310
1311impl fidl::Persistable for AudioConsumerWatchStatusResponse {}
1312
1313#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1314pub struct AudioCoreEnableDeviceSettingsRequest {
1315 pub enabled: bool,
1316}
1317
1318impl fidl::Persistable for AudioCoreEnableDeviceSettingsRequest {}
1319
1320#[derive(Clone, Debug, PartialEq)]
1321pub struct AudioCoreGetDbFromVolume2Request {
1322 pub usage: Usage2,
1323 pub volume: f32,
1324}
1325
1326impl fidl::Persistable for AudioCoreGetDbFromVolume2Request {}
1327
1328#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1329pub struct AudioCoreGetDbFromVolumeRequest {
1330 pub usage: Usage,
1331 pub volume: f32,
1332}
1333
1334impl fidl::Persistable for AudioCoreGetDbFromVolumeRequest {}
1335
1336#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1337pub struct AudioCoreGetDbFromVolumeResponse {
1338 pub gain_db: f32,
1339}
1340
1341impl fidl::Persistable for AudioCoreGetDbFromVolumeResponse {}
1342
1343#[derive(Clone, Debug, PartialEq)]
1344pub struct AudioCoreGetVolumeFromDb2Request {
1345 pub usage: Usage2,
1346 pub gain_db: f32,
1347}
1348
1349impl fidl::Persistable for AudioCoreGetVolumeFromDb2Request {}
1350
1351#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1352pub struct AudioCoreGetVolumeFromDbRequest {
1353 pub usage: Usage,
1354 pub gain_db: f32,
1355}
1356
1357impl fidl::Persistable for AudioCoreGetVolumeFromDbRequest {}
1358
1359#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1360pub struct AudioCoreGetVolumeFromDbResponse {
1361 pub volume: f32,
1362}
1363
1364impl fidl::Persistable for AudioCoreGetVolumeFromDbResponse {}
1365
1366#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1367pub struct AudioCoreSetCaptureUsageGain2Request {
1368 pub usage: AudioCaptureUsage2,
1369 pub gain_db: f32,
1370}
1371
1372impl fidl::Persistable for AudioCoreSetCaptureUsageGain2Request {}
1373
1374#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1375pub struct AudioCoreSetCaptureUsageGainRequest {
1376 pub usage: AudioCaptureUsage,
1377 pub gain_db: f32,
1378}
1379
1380impl fidl::Persistable for AudioCoreSetCaptureUsageGainRequest {}
1381
1382#[derive(Clone, Debug, PartialEq)]
1383pub struct AudioCoreSetInteraction2Request {
1384 pub active: Usage2,
1385 pub affected: Usage2,
1386 pub behavior: Behavior,
1387}
1388
1389impl fidl::Persistable for AudioCoreSetInteraction2Request {}
1390
1391#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1392pub struct AudioCoreSetInteractionRequest {
1393 pub active: Usage,
1394 pub affected: Usage,
1395 pub behavior: Behavior,
1396}
1397
1398impl fidl::Persistable for AudioCoreSetInteractionRequest {}
1399
1400#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1401pub struct AudioCoreSetRenderUsageGain2Request {
1402 pub usage: AudioRenderUsage2,
1403 pub gain_db: f32,
1404}
1405
1406impl fidl::Persistable for AudioCoreSetRenderUsageGain2Request {}
1407
1408#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1409pub struct AudioCoreSetRenderUsageGainRequest {
1410 pub usage: AudioRenderUsage,
1411 pub gain_db: f32,
1412}
1413
1414impl fidl::Persistable for AudioCoreSetRenderUsageGainRequest {}
1415
1416#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1417pub struct AudioCoreGetDbFromVolume2Response {
1418 pub gain_db: f32,
1419}
1420
1421impl fidl::Persistable for AudioCoreGetDbFromVolume2Response {}
1422
1423#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1424pub struct AudioCoreGetVolumeFromDb2Response {
1425 pub volume: f32,
1426}
1427
1428impl fidl::Persistable for AudioCoreGetVolumeFromDb2Response {}
1429
1430#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1431#[repr(C)]
1432pub struct AudioDeviceEnumeratorGetDeviceGainRequest {
1433 pub device_token: u64,
1434}
1435
1436impl fidl::Persistable for AudioDeviceEnumeratorGetDeviceGainRequest {}
1437
1438#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1439pub struct AudioDeviceEnumeratorGetDeviceGainResponse {
1440 pub device_token: u64,
1441 pub gain_info: AudioGainInfo,
1442}
1443
1444impl fidl::Persistable for AudioDeviceEnumeratorGetDeviceGainResponse {}
1445
1446#[derive(Clone, Debug, PartialEq, PartialOrd)]
1447pub struct AudioDeviceEnumeratorGetDevicesResponse {
1448 pub devices: Vec<AudioDeviceInfo>,
1449}
1450
1451impl fidl::Persistable for AudioDeviceEnumeratorGetDevicesResponse {}
1452
1453#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1454#[repr(C)]
1455pub struct AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
1456 pub old_default_token: u64,
1457 pub new_default_token: u64,
1458}
1459
1460impl fidl::Persistable for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {}
1461
1462#[derive(Clone, Debug, PartialEq, PartialOrd)]
1463pub struct AudioDeviceEnumeratorOnDeviceAddedRequest {
1464 pub device: AudioDeviceInfo,
1465}
1466
1467impl fidl::Persistable for AudioDeviceEnumeratorOnDeviceAddedRequest {}
1468
1469#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1470pub struct AudioDeviceEnumeratorOnDeviceGainChangedRequest {
1471 pub device_token: u64,
1472 pub gain_info: AudioGainInfo,
1473}
1474
1475impl fidl::Persistable for AudioDeviceEnumeratorOnDeviceGainChangedRequest {}
1476
1477#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1478#[repr(C)]
1479pub struct AudioDeviceEnumeratorOnDeviceRemovedRequest {
1480 pub device_token: u64,
1481}
1482
1483impl fidl::Persistable for AudioDeviceEnumeratorOnDeviceRemovedRequest {}
1484
1485#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1486pub struct AudioDeviceEnumeratorSetDeviceGainRequest {
1487 pub device_token: u64,
1488 pub gain_info: AudioGainInfo,
1489 pub valid_flags: AudioGainValidFlags,
1490}
1491
1492impl fidl::Persistable for AudioDeviceEnumeratorSetDeviceGainRequest {}
1493
1494#[derive(Clone, Debug, PartialEq, PartialOrd)]
1495pub struct AudioDeviceInfo {
1496 pub name: String,
1497 pub unique_id: String,
1498 pub token_id: u64,
1499 pub is_input: bool,
1500 pub gain_info: AudioGainInfo,
1501 pub is_default: bool,
1502}
1503
1504impl fidl::Persistable for AudioDeviceInfo {}
1505
1506#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1507pub struct AudioGainInfo {
1508 pub gain_db: f32,
1509 pub flags: AudioGainInfoFlags,
1510}
1511
1512impl fidl::Persistable for AudioGainInfo {}
1513
1514#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1515pub struct AudioRendererEnableMinLeadTimeEventsRequest {
1516 pub enabled: bool,
1517}
1518
1519impl fidl::Persistable for AudioRendererEnableMinLeadTimeEventsRequest {}
1520
1521#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1522#[repr(C)]
1523pub struct AudioRendererGetMinLeadTimeResponse {
1524 pub min_lead_time_nsec: i64,
1525}
1526
1527impl fidl::Persistable for AudioRendererGetMinLeadTimeResponse {}
1528
1529#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1530#[repr(C)]
1531pub struct AudioRendererOnMinLeadTimeChangedRequest {
1532 pub min_lead_time_nsec: i64,
1533}
1534
1535impl fidl::Persistable for AudioRendererOnMinLeadTimeChangedRequest {}
1536
1537#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1538#[repr(C)]
1539pub struct AudioRendererPauseResponse {
1540 pub reference_time: i64,
1541 pub media_time: i64,
1542}
1543
1544impl fidl::Persistable for AudioRendererPauseResponse {}
1545
1546#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1547#[repr(C)]
1548pub struct AudioRendererPlayNoReplyRequest {
1549 pub reference_time: i64,
1550 pub media_time: i64,
1551}
1552
1553impl fidl::Persistable for AudioRendererPlayNoReplyRequest {}
1554
1555#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1556#[repr(C)]
1557pub struct AudioRendererPlayRequest {
1558 pub reference_time: i64,
1559 pub media_time: i64,
1560}
1561
1562impl fidl::Persistable for AudioRendererPlayRequest {}
1563
1564#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1565#[repr(C)]
1566pub struct AudioRendererPlayResponse {
1567 pub reference_time: i64,
1568 pub media_time: i64,
1569}
1570
1571impl fidl::Persistable for AudioRendererPlayResponse {}
1572
1573#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1574pub struct AudioRendererSetPcmStreamTypeRequest {
1575 pub type_: AudioStreamType,
1576}
1577
1578impl fidl::Persistable for AudioRendererSetPcmStreamTypeRequest {}
1579
1580#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
1581pub struct AudioRendererSetPtsContinuityThresholdRequest {
1582 pub threshold_seconds: f32,
1583}
1584
1585impl fidl::Persistable for AudioRendererSetPtsContinuityThresholdRequest {}
1586
1587#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1588#[repr(C)]
1589pub struct AudioRendererSetPtsUnitsRequest {
1590 pub tick_per_second_numerator: u32,
1591 pub tick_per_second_denominator: u32,
1592}
1593
1594impl fidl::Persistable for AudioRendererSetPtsUnitsRequest {}
1595
1596#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1597pub struct AudioRendererSetUsage2Request {
1598 pub usage2: AudioRenderUsage2,
1599}
1600
1601impl fidl::Persistable for AudioRendererSetUsage2Request {}
1602
1603#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1604pub struct AudioRendererSetUsageRequest {
1605 pub usage: AudioRenderUsage,
1606}
1607
1608impl fidl::Persistable for AudioRendererSetUsageRequest {}
1609
1610#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1612pub struct AudioStreamType {
1613 pub sample_format: AudioSampleFormat,
1614 pub channels: u32,
1615 pub frames_per_second: u32,
1616}
1617
1618impl fidl::Persistable for AudioStreamType {}
1619
1620#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1623pub struct Compression {
1624 pub type_: String,
1628 pub parameters: Option<Vec<u8>>,
1630}
1631
1632impl fidl::Persistable for Compression {}
1633
1634#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1641#[repr(C)]
1642pub struct EncryptionPattern {
1643 pub clear_blocks: u32,
1644 pub encrypted_blocks: u32,
1645}
1646
1647impl fidl::Persistable for EncryptionPattern {}
1648
1649#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1650pub struct Metadata {
1651 pub properties: Vec<Property>,
1652}
1653
1654impl fidl::Persistable for Metadata {}
1655
1656#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1663pub struct Parameter {
1664 pub scope: String,
1665 pub name: String,
1666 pub value: Value,
1667}
1668
1669impl fidl::Persistable for Parameter {}
1670
1671#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1675pub struct PcmFormat {
1676 pub pcm_mode: AudioPcmMode,
1677 pub bits_per_sample: u32,
1678 pub frames_per_second: u32,
1679 pub channel_map: Vec<AudioChannelId>,
1680}
1681
1682impl fidl::Persistable for PcmFormat {}
1683
1684#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1685#[repr(C)]
1686pub struct ProfileProviderRegisterHandlerWithCapacityResponse {
1687 pub period: i64,
1688 pub capacity: i64,
1689}
1690
1691impl fidl::Persistable for ProfileProviderRegisterHandlerWithCapacityResponse {}
1692
1693#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1694pub struct Property {
1695 pub label: String,
1696 pub value: String,
1697}
1698
1699impl fidl::Persistable for Property {}
1700
1701#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1709pub struct SbcEncoderSettings {
1710 pub sub_bands: SbcSubBands,
1711 pub allocation: SbcAllocation,
1712 pub block_count: SbcBlockCount,
1713 pub channel_mode: SbcChannelMode,
1714 pub bit_pool: u64,
1716}
1717
1718impl fidl::Persistable for SbcEncoderSettings {}
1719
1720#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1721#[repr(C)]
1722pub struct StreamBufferSetRemovePayloadBufferRequest {
1723 pub id: u32,
1724}
1725
1726impl fidl::Persistable for StreamBufferSetRemovePayloadBufferRequest {}
1727
1728#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1730#[repr(C)]
1731pub struct StreamPacket {
1732 pub pts: i64,
1735 pub payload_buffer_id: u32,
1742 pub payload_offset: u64,
1747 pub payload_size: u64,
1752 pub flags: u32,
1755 pub buffer_config: u64,
1763 pub stream_segment_id: u64,
1769}
1770
1771impl fidl::Persistable for StreamPacket {}
1772
1773#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1774pub struct StreamProcessorCloseCurrentStreamRequest {
1775 pub stream_lifetime_ordinal: u64,
1776 pub release_input_buffers: bool,
1777 pub release_output_buffers: bool,
1778}
1779
1780impl fidl::Persistable for StreamProcessorCloseCurrentStreamRequest {}
1781
1782#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1783#[repr(C)]
1784pub struct StreamProcessorCompleteOutputBufferPartialSettingsRequest {
1785 pub buffer_lifetime_ordinal: u64,
1786}
1787
1788impl fidl::Persistable for StreamProcessorCompleteOutputBufferPartialSettingsRequest {}
1789
1790#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1791#[repr(C)]
1792pub struct StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
1793 pub stream_lifetime_ordinal: u64,
1794}
1795
1796impl fidl::Persistable for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {}
1797
1798#[derive(Clone, Debug, PartialEq)]
1799pub struct StreamProcessorOnFreeInputPacketRequest {
1800 pub free_input_packet: PacketHeader,
1801}
1802
1803impl fidl::Persistable for StreamProcessorOnFreeInputPacketRequest {}
1804
1805#[derive(Clone, Debug, PartialEq)]
1806pub struct StreamProcessorOnInputConstraintsRequest {
1807 pub input_constraints: StreamBufferConstraints,
1808}
1809
1810impl fidl::Persistable for StreamProcessorOnInputConstraintsRequest {}
1811
1812#[derive(Clone, Debug, PartialEq)]
1813pub struct StreamProcessorOnOutputConstraintsRequest {
1814 pub output_config: StreamOutputConstraints,
1815}
1816
1817impl fidl::Persistable for StreamProcessorOnOutputConstraintsRequest {}
1818
1819#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1820pub struct StreamProcessorOnOutputEndOfStreamRequest {
1821 pub stream_lifetime_ordinal: u64,
1822 pub error_detected_before: bool,
1823}
1824
1825impl fidl::Persistable for StreamProcessorOnOutputEndOfStreamRequest {}
1826
1827#[derive(Clone, Debug, PartialEq)]
1828pub struct StreamProcessorOnOutputFormatRequest {
1829 pub output_format: StreamOutputFormat,
1830}
1831
1832impl fidl::Persistable for StreamProcessorOnOutputFormatRequest {}
1833
1834#[derive(Clone, Debug, PartialEq)]
1835pub struct StreamProcessorOnOutputPacketRequest {
1836 pub output_packet: Packet,
1837 pub error_detected_before: bool,
1838 pub error_detected_during: bool,
1839}
1840
1841impl fidl::Persistable for StreamProcessorOnOutputPacketRequest {}
1842
1843#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1844pub struct StreamProcessorOnStreamFailedRequest {
1845 pub stream_lifetime_ordinal: u64,
1846 pub error: StreamError,
1847}
1848
1849impl fidl::Persistable for StreamProcessorOnStreamFailedRequest {}
1850
1851#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1852#[repr(C)]
1853pub struct StreamProcessorQueueInputEndOfStreamRequest {
1854 pub stream_lifetime_ordinal: u64,
1855}
1856
1857impl fidl::Persistable for StreamProcessorQueueInputEndOfStreamRequest {}
1858
1859#[derive(Clone, Debug, PartialEq)]
1860pub struct StreamProcessorQueueInputFormatDetailsRequest {
1861 pub stream_lifetime_ordinal: u64,
1862 pub format_details: FormatDetails,
1863}
1864
1865impl fidl::Persistable for StreamProcessorQueueInputFormatDetailsRequest {}
1866
1867#[derive(Clone, Debug, PartialEq)]
1868pub struct StreamProcessorQueueInputPacketRequest {
1869 pub packet: Packet,
1870}
1871
1872impl fidl::Persistable for StreamProcessorQueueInputPacketRequest {}
1873
1874#[derive(Clone, Debug, PartialEq)]
1875pub struct StreamProcessorRecycleOutputPacketRequest {
1876 pub available_output_packet: PacketHeader,
1877}
1878
1879impl fidl::Persistable for StreamProcessorRecycleOutputPacketRequest {}
1880
1881#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1882#[repr(C)]
1883pub struct StreamSinkSendPacketNoReplyRequest {
1884 pub packet: StreamPacket,
1885}
1886
1887impl fidl::Persistable for StreamSinkSendPacketNoReplyRequest {}
1888
1889#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1890#[repr(C)]
1891pub struct StreamSinkSendPacketRequest {
1892 pub packet: StreamPacket,
1893}
1894
1895impl fidl::Persistable for StreamSinkSendPacketRequest {}
1896
1897#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1898#[repr(C)]
1899pub struct StreamSourceOnPacketProducedRequest {
1900 pub packet: StreamPacket,
1901}
1902
1903impl fidl::Persistable for StreamSourceOnPacketProducedRequest {}
1904
1905#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1906#[repr(C)]
1907pub struct StreamSourceReleasePacketRequest {
1908 pub packet: StreamPacket,
1909}
1910
1911impl fidl::Persistable for StreamSourceReleasePacketRequest {}
1912
1913#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1915pub struct StreamType {
1916 pub medium_specific: MediumSpecificStreamType,
1918 pub encoding: String,
1921 pub encoding_parameters: Option<Vec<u8>>,
1927}
1928
1929impl fidl::Persistable for StreamType {}
1930
1931#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1933pub struct SubpictureStreamType;
1934
1935impl fidl::Persistable for SubpictureStreamType {}
1936
1937#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1943#[repr(C)]
1944pub struct SubsampleEntry {
1945 pub clear_bytes: u32,
1946 pub encrypted_bytes: u32,
1947}
1948
1949impl fidl::Persistable for SubsampleEntry {}
1950
1951#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1953pub struct TextStreamType;
1954
1955impl fidl::Persistable for TextStreamType {}
1956
1957#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1993#[repr(C)]
1994pub struct TimelineFunction {
1995 pub subject_time: i64,
1997 pub reference_time: i64,
1999 pub subject_delta: u32,
2001 pub reference_delta: u32,
2004}
2005
2006impl fidl::Persistable for TimelineFunction {}
2007
2008#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
2009pub struct UsageGainListenerOnGainMuteChangedRequest {
2010 pub muted: bool,
2011 pub gain_dbfs: f32,
2012}
2013
2014impl fidl::Persistable for UsageGainListenerOnGainMuteChangedRequest {}
2015
2016#[derive(Clone, Debug, PartialEq)]
2017pub struct UsageWatcher2OnStateChangedRequest {
2018 pub usage: Usage2,
2019 pub state: UsageState,
2020}
2021
2022impl fidl::Persistable for UsageWatcher2OnStateChangedRequest {}
2023
2024#[derive(Clone, Debug, PartialEq)]
2025pub struct UsageWatcherOnStateChangedRequest {
2026 pub usage: Usage,
2027 pub state: UsageState,
2028}
2029
2030impl fidl::Persistable for UsageWatcherOnStateChangedRequest {}
2031
2032#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
2034pub struct VideoStreamType {
2035 pub pixel_format: fidl_fuchsia_images__common::PixelFormat,
2036 pub color_space: ColorSpace,
2037 pub width: u32,
2039 pub height: u32,
2040 pub coded_width: u32,
2043 pub coded_height: u32,
2044 pub pixel_aspect_ratio_width: u32,
2047 pub pixel_aspect_ratio_height: u32,
2048 pub stride: u32,
2050}
2051
2052impl fidl::Persistable for VideoStreamType {}
2053
2054#[derive(Clone, Debug, PartialEq)]
2058pub struct VideoUncompressedFormat {
2059 pub image_format: fidl_fuchsia_sysmem__common::ImageFormat2,
2060 pub fourcc: u32,
2061 pub primary_width_pixels: u32,
2062 pub primary_height_pixels: u32,
2063 pub secondary_width_pixels: u32,
2064 pub secondary_height_pixels: u32,
2065 pub planar: bool,
2066 pub swizzled: bool,
2067 pub primary_line_stride_bytes: u32,
2068 pub secondary_line_stride_bytes: u32,
2069 pub primary_start_offset: u32,
2070 pub secondary_start_offset: u32,
2071 pub tertiary_start_offset: u32,
2072 pub primary_pixel_stride: u32,
2073 pub secondary_pixel_stride: u32,
2074 pub primary_display_width_pixels: u32,
2075 pub primary_display_height_pixels: u32,
2076 pub has_pixel_aspect_ratio: bool,
2077 pub pixel_aspect_ratio_width: u32,
2078 pub pixel_aspect_ratio_height: u32,
2079}
2080
2081impl fidl::Persistable for VideoUncompressedFormat {}
2082
2083#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
2084pub struct Void;
2085
2086impl fidl::Persistable for Void {}
2087
2088#[derive(Clone, Debug, Default, PartialEq)]
2092pub struct AudioCompressedFormatCvsd {
2093 #[doc(hidden)]
2094 pub __source_breaking: fidl::marker::SourceBreaking,
2095}
2096
2097impl fidl::Persistable for AudioCompressedFormatCvsd {}
2098
2099#[derive(Clone, Debug, Default, PartialEq)]
2103pub struct AudioCompressedFormatLc3 {
2104 #[doc(hidden)]
2105 pub __source_breaking: fidl::marker::SourceBreaking,
2106}
2107
2108impl fidl::Persistable for AudioCompressedFormatLc3 {}
2109
2110#[derive(Clone, Debug, Default, PartialEq)]
2113pub struct AudioConsumerStatus {
2114 pub error: Option<AudioConsumerError>,
2116 pub presentation_timeline: Option<TimelineFunction>,
2124 pub min_lead_time: Option<u64>,
2129 pub max_lead_time: Option<u64>,
2134 #[doc(hidden)]
2135 pub __source_breaking: fidl::marker::SourceBreaking,
2136}
2137
2138impl fidl::Persistable for AudioConsumerStatus {}
2139
2140#[derive(Clone, Debug, Default, PartialEq)]
2144pub struct CvsdEncoderSettings {
2145 #[doc(hidden)]
2146 pub __source_breaking: fidl::marker::SourceBreaking,
2147}
2148
2149impl fidl::Persistable for CvsdEncoderSettings {}
2150
2151#[derive(Clone, Debug, Default, PartialEq)]
2157pub struct DecryptedFormat {
2158 pub ignore_this_field: Option<bool>,
2159 #[doc(hidden)]
2160 pub __source_breaking: fidl::marker::SourceBreaking,
2161}
2162
2163impl fidl::Persistable for DecryptedFormat {}
2164
2165#[derive(Clone, Debug, Default, PartialEq)]
2172pub struct EncryptedFormat {
2173 pub init_vector: Option<Vec<u8>>,
2181 pub subsamples: Option<Vec<SubsampleEntry>>,
2187 pub pattern: Option<EncryptionPattern>,
2195 pub scheme: Option<String>,
2205 pub key_id: Option<Vec<u8>>,
2212 #[doc(hidden)]
2213 pub __source_breaking: fidl::marker::SourceBreaking,
2214}
2215
2216impl fidl::Persistable for EncryptedFormat {}
2217
2218#[derive(Clone, Debug, Default, PartialEq)]
2223pub struct FormatDetails {
2224 pub format_details_version_ordinal: Option<u64>,
2225 pub mime_type: Option<String>,
2226 pub oob_bytes: Option<Vec<u8>>,
2227 pub domain: Option<DomainFormat>,
2228 pub pass_through_parameters: Option<Vec<Parameter>>,
2229 pub encoder_settings: Option<EncoderSettings>,
2234 pub timebase: Option<u64>,
2248 pub profile: Option<CodecProfile>,
2261 #[doc(hidden)]
2262 pub __source_breaking: fidl::marker::SourceBreaking,
2263}
2264
2265impl fidl::Persistable for FormatDetails {}
2266
2267#[derive(Clone, Debug, Default, PartialEq)]
2269pub struct H264EncoderSettings {
2270 pub bit_rate: Option<u32>,
2273 pub frame_rate: Option<u32>,
2276 pub gop_size: Option<u32>,
2280 pub variable_frame_rate: Option<bool>,
2283 pub min_frame_rate: Option<u32>,
2286 pub force_key_frame: Option<bool>,
2289 pub quantization_params: Option<H264QuantizationParameters>,
2293 #[doc(hidden)]
2294 pub __source_breaking: fidl::marker::SourceBreaking,
2295}
2296
2297impl fidl::Persistable for H264EncoderSettings {}
2298
2299#[derive(Clone, Debug, Default, PartialEq)]
2308pub struct H264QuantizationParameters {
2309 pub i_base: Option<u32>,
2311 pub i_min: Option<u32>,
2313 pub i_max: Option<u32>,
2315 pub p_base: Option<u32>,
2317 pub p_min: Option<u32>,
2319 pub p_max: Option<u32>,
2321 #[doc(hidden)]
2322 pub __source_breaking: fidl::marker::SourceBreaking,
2323}
2324
2325impl fidl::Persistable for H264QuantizationParameters {}
2326
2327#[derive(Clone, Debug, Default, PartialEq)]
2329pub struct HevcEncoderSettings {
2330 pub bit_rate: Option<u32>,
2333 pub frame_rate: Option<u32>,
2335 pub gop_size: Option<u32>,
2337 #[doc(hidden)]
2338 pub __source_breaking: fidl::marker::SourceBreaking,
2339}
2340
2341impl fidl::Persistable for HevcEncoderSettings {}
2342
2343#[derive(Clone, Debug, Default, PartialEq)]
2346pub struct InputAudioCapturerConfiguration {
2347 pub usage: Option<AudioCaptureUsage>,
2348 pub usage2: Option<AudioCaptureUsage2>,
2349 #[doc(hidden)]
2350 pub __source_breaking: fidl::marker::SourceBreaking,
2351}
2352
2353impl fidl::Persistable for InputAudioCapturerConfiguration {}
2354
2355#[derive(Clone, Debug, Default, PartialEq)]
2358pub struct Lc3EncoderSettings {
2359 pub nbytes: Option<u16>,
2364 pub frame_duration: Option<Lc3FrameDuration>,
2367 #[doc(hidden)]
2368 pub __source_breaking: fidl::marker::SourceBreaking,
2369}
2370
2371impl fidl::Persistable for Lc3EncoderSettings {}
2372
2373#[derive(Clone, Debug, Default, PartialEq)]
2376pub struct LoopbackAudioCapturerConfiguration {
2377 #[doc(hidden)]
2378 pub __source_breaking: fidl::marker::SourceBreaking,
2379}
2380
2381impl fidl::Persistable for LoopbackAudioCapturerConfiguration {}
2382
2383#[derive(Clone, Debug, Default, PartialEq)]
2386pub struct MSbcEncoderSettings {
2387 #[doc(hidden)]
2388 pub __source_breaking: fidl::marker::SourceBreaking,
2389}
2390
2391impl fidl::Persistable for MSbcEncoderSettings {}
2392
2393#[derive(Clone, Debug, Default, PartialEq)]
2410pub struct Packet {
2411 pub header: Option<PacketHeader>,
2412 pub buffer_index: Option<u32>,
2426 pub stream_lifetime_ordinal: Option<u64>,
2435 pub start_offset: Option<u32>,
2454 pub valid_length_bytes: Option<u32>,
2477 pub timestamp_ish: Option<u64>,
2497 pub start_access_unit: Option<bool>,
2508 pub known_end_access_unit: Option<bool>,
2520 pub key_frame: Option<bool>,
2524 #[doc(hidden)]
2525 pub __source_breaking: fidl::marker::SourceBreaking,
2526}
2527
2528impl fidl::Persistable for Packet {}
2529
2530#[derive(Clone, Debug, Default, PartialEq)]
2538pub struct PacketHeader {
2539 pub buffer_lifetime_ordinal: Option<u64>,
2552 pub packet_index: Option<u32>,
2572 #[doc(hidden)]
2573 pub __source_breaking: fidl::marker::SourceBreaking,
2574}
2575
2576impl fidl::Persistable for PacketHeader {}
2577
2578#[derive(Clone, Debug, Default, PartialEq)]
2591pub struct StreamBufferConstraints {
2592 pub buffer_constraints_version_ordinal: Option<u64>,
2607 pub default_settings: Option<StreamBufferSettings>,
2608 pub per_packet_buffer_bytes_min: Option<u32>,
2609 pub per_packet_buffer_bytes_recommended: Option<u32>,
2610 pub per_packet_buffer_bytes_max: Option<u32>,
2611 pub packet_count_for_server_min: Option<u32>,
2612 pub packet_count_for_server_recommended: Option<u32>,
2613 pub packet_count_for_server_recommended_max: Option<u32>,
2614 pub packet_count_for_server_max: Option<u32>,
2615 pub packet_count_for_client_min: Option<u32>,
2616 pub packet_count_for_client_max: Option<u32>,
2617 pub single_buffer_mode_allowed: Option<bool>,
2618 pub is_physically_contiguous_required: Option<bool>,
2619 #[doc(hidden)]
2620 pub __source_breaking: fidl::marker::SourceBreaking,
2621}
2622
2623impl fidl::Persistable for StreamBufferConstraints {}
2624
2625#[derive(Clone, Debug, Default, PartialEq)]
2628pub struct StreamBufferSettings {
2629 pub buffer_lifetime_ordinal: Option<u64>,
2630 pub buffer_constraints_version_ordinal: Option<u64>,
2631 pub packet_count_for_server: Option<u32>,
2632 pub packet_count_for_client: Option<u32>,
2633 pub per_packet_buffer_bytes: Option<u32>,
2634 pub single_buffer_mode: Option<bool>,
2635 #[doc(hidden)]
2636 pub __source_breaking: fidl::marker::SourceBreaking,
2637}
2638
2639impl fidl::Persistable for StreamBufferSettings {}
2640
2641#[derive(Clone, Debug, Default, PartialEq)]
2644pub struct StreamOutputConstraints {
2645 pub stream_lifetime_ordinal: Option<u64>,
2659 pub buffer_constraints_action_required: Option<bool>,
2688 pub buffer_constraints: Option<StreamBufferConstraints>,
2689 #[doc(hidden)]
2690 pub __source_breaking: fidl::marker::SourceBreaking,
2691}
2692
2693impl fidl::Persistable for StreamOutputConstraints {}
2694
2695#[derive(Clone, Debug, Default, PartialEq)]
2696pub struct StreamOutputFormat {
2697 pub stream_lifetime_ordinal: Option<u64>,
2710 pub format_details: Option<FormatDetails>,
2767 #[doc(hidden)]
2768 pub __source_breaking: fidl::marker::SourceBreaking,
2769}
2770
2771impl fidl::Persistable for StreamOutputFormat {}
2772
2773#[derive(Clone, Debug, Default, PartialEq)]
2776pub struct UsageStateDucked {
2777 #[doc(hidden)]
2778 pub __source_breaking: fidl::marker::SourceBreaking,
2779}
2780
2781impl fidl::Persistable for UsageStateDucked {}
2782
2783#[derive(Clone, Debug, Default, PartialEq)]
2786pub struct UsageStateMuted {
2787 #[doc(hidden)]
2788 pub __source_breaking: fidl::marker::SourceBreaking,
2789}
2790
2791impl fidl::Persistable for UsageStateMuted {}
2792
2793#[derive(Clone, Debug, Default, PartialEq)]
2795pub struct UsageStateUnadjusted {
2796 #[doc(hidden)]
2797 pub __source_breaking: fidl::marker::SourceBreaking,
2798}
2799
2800impl fidl::Persistable for UsageStateUnadjusted {}
2801
2802#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
2803pub enum AacBitRate {
2804 Constant(AacConstantBitRate),
2805 Variable(AacVariableBitRate),
2806}
2807
2808impl AacBitRate {
2809 #[inline]
2810 pub fn ordinal(&self) -> u64 {
2811 match *self {
2812 Self::Constant(_) => 1,
2813 Self::Variable(_) => 2,
2814 }
2815 }
2816}
2817
2818impl fidl::Persistable for AacBitRate {}
2819
2820#[derive(Clone, Debug)]
2821pub enum AacTransport {
2822 Raw(AacTransportRaw),
2823 Latm(AacTransportLatm),
2824 Adts(AacTransportAdts),
2825 #[doc(hidden)]
2826 __SourceBreaking {
2827 unknown_ordinal: u64,
2828 },
2829}
2830
2831#[macro_export]
2833macro_rules! AacTransportUnknown {
2834 () => {
2835 _
2836 };
2837}
2838
2839impl PartialEq for AacTransport {
2841 fn eq(&self, other: &Self) -> bool {
2842 match (self, other) {
2843 (Self::Raw(x), Self::Raw(y)) => *x == *y,
2844 (Self::Latm(x), Self::Latm(y)) => *x == *y,
2845 (Self::Adts(x), Self::Adts(y)) => *x == *y,
2846 _ => false,
2847 }
2848 }
2849}
2850
2851impl AacTransport {
2852 #[inline]
2853 pub fn ordinal(&self) -> u64 {
2854 match *self {
2855 Self::Raw(_) => 1,
2856 Self::Latm(_) => 2,
2857 Self::Adts(_) => 3,
2858 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2859 }
2860 }
2861
2862 #[inline]
2863 pub fn unknown_variant_for_testing() -> Self {
2864 Self::__SourceBreaking { unknown_ordinal: 0 }
2865 }
2866
2867 #[inline]
2868 pub fn is_unknown(&self) -> bool {
2869 match self {
2870 Self::__SourceBreaking { .. } => true,
2871 _ => false,
2872 }
2873 }
2874}
2875
2876impl fidl::Persistable for AacTransport {}
2877
2878#[derive(Clone, Debug, PartialEq)]
2880pub enum AudioCapturerConfiguration {
2881 Loopback(LoopbackAudioCapturerConfiguration),
2882 Input(InputAudioCapturerConfiguration),
2883}
2884
2885impl AudioCapturerConfiguration {
2886 #[inline]
2887 pub fn ordinal(&self) -> u64 {
2888 match *self {
2889 Self::Loopback(_) => 1,
2890 Self::Input(_) => 2,
2891 }
2892 }
2893}
2894
2895impl fidl::Persistable for AudioCapturerConfiguration {}
2896
2897#[derive(Clone, Debug)]
2898pub enum AudioCompressedFormat {
2899 Aac(AudioCompressedFormatAac),
2900 Sbc(AudioCompressedFormatSbc),
2901 Cvsd(AudioCompressedFormatCvsd),
2902 Lc3(AudioCompressedFormatLc3),
2903 #[doc(hidden)]
2904 __SourceBreaking {
2905 unknown_ordinal: u64,
2906 },
2907}
2908
2909#[macro_export]
2911macro_rules! AudioCompressedFormatUnknown {
2912 () => {
2913 _
2914 };
2915}
2916
2917impl PartialEq for AudioCompressedFormat {
2919 fn eq(&self, other: &Self) -> bool {
2920 match (self, other) {
2921 (Self::Aac(x), Self::Aac(y)) => *x == *y,
2922 (Self::Sbc(x), Self::Sbc(y)) => *x == *y,
2923 (Self::Cvsd(x), Self::Cvsd(y)) => *x == *y,
2924 (Self::Lc3(x), Self::Lc3(y)) => *x == *y,
2925 _ => false,
2926 }
2927 }
2928}
2929
2930impl AudioCompressedFormat {
2931 #[inline]
2932 pub fn ordinal(&self) -> u64 {
2933 match *self {
2934 Self::Aac(_) => 1,
2935 Self::Sbc(_) => 2,
2936 Self::Cvsd(_) => 3,
2937 Self::Lc3(_) => 4,
2938 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2939 }
2940 }
2941
2942 #[inline]
2943 pub fn unknown_variant_for_testing() -> Self {
2944 Self::__SourceBreaking { unknown_ordinal: 0 }
2945 }
2946
2947 #[inline]
2948 pub fn is_unknown(&self) -> bool {
2949 match self {
2950 Self::__SourceBreaking { .. } => true,
2951 _ => false,
2952 }
2953 }
2954}
2955
2956impl fidl::Persistable for AudioCompressedFormat {}
2957
2958#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
2960pub enum AudioConsumerError {
2961 PlaceHolder(Void),
2962}
2963
2964impl AudioConsumerError {
2965 #[inline]
2966 pub fn ordinal(&self) -> u64 {
2967 match *self {
2968 Self::PlaceHolder(_) => 1,
2969 }
2970 }
2971}
2972
2973impl fidl::Persistable for AudioConsumerError {}
2974
2975#[derive(Clone, Debug, PartialEq)]
2977pub enum AudioFormat {
2978 Compressed(AudioCompressedFormat),
2979 Uncompressed(AudioUncompressedFormat),
2980}
2981
2982impl AudioFormat {
2983 #[inline]
2984 pub fn ordinal(&self) -> u64 {
2985 match *self {
2986 Self::Compressed(_) => 1,
2987 Self::Uncompressed(_) => 2,
2988 }
2989 }
2990}
2991
2992impl fidl::Persistable for AudioFormat {}
2993
2994#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
2996pub enum AudioUncompressedFormat {
2997 Pcm(PcmFormat),
2998}
2999
3000impl AudioUncompressedFormat {
3001 #[inline]
3002 pub fn ordinal(&self) -> u64 {
3003 match *self {
3004 Self::Pcm(_) => 1,
3005 }
3006 }
3007}
3008
3009impl fidl::Persistable for AudioUncompressedFormat {}
3010
3011#[derive(Clone, Debug)]
3015pub enum CryptoFormat {
3016 Encrypted(EncryptedFormat),
3017 Decrypted(DecryptedFormat),
3018 #[doc(hidden)]
3019 __SourceBreaking {
3020 unknown_ordinal: u64,
3021 },
3022}
3023
3024#[macro_export]
3026macro_rules! CryptoFormatUnknown {
3027 () => {
3028 _
3029 };
3030}
3031
3032impl PartialEq for CryptoFormat {
3034 fn eq(&self, other: &Self) -> bool {
3035 match (self, other) {
3036 (Self::Encrypted(x), Self::Encrypted(y)) => *x == *y,
3037 (Self::Decrypted(x), Self::Decrypted(y)) => *x == *y,
3038 _ => false,
3039 }
3040 }
3041}
3042
3043impl CryptoFormat {
3044 #[inline]
3045 pub fn ordinal(&self) -> u64 {
3046 match *self {
3047 Self::Encrypted(_) => 1,
3048 Self::Decrypted(_) => 2,
3049 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
3050 }
3051 }
3052
3053 #[inline]
3054 pub fn unknown_variant_for_testing() -> Self {
3055 Self::__SourceBreaking { unknown_ordinal: 0 }
3056 }
3057
3058 #[inline]
3059 pub fn is_unknown(&self) -> bool {
3060 match self {
3061 Self::__SourceBreaking { .. } => true,
3062 _ => false,
3063 }
3064 }
3065}
3066
3067impl fidl::Persistable for CryptoFormat {}
3068
3069#[derive(Clone, Debug, PartialEq)]
3071pub enum DomainFormat {
3072 Audio(AudioFormat),
3073 Video(VideoFormat),
3074 Crypto(CryptoFormat),
3075}
3076
3077impl DomainFormat {
3078 #[inline]
3079 pub fn ordinal(&self) -> u64 {
3080 match *self {
3081 Self::Audio(_) => 1,
3082 Self::Video(_) => 2,
3083 Self::Crypto(_) => 3,
3084 }
3085 }
3086}
3087
3088impl fidl::Persistable for DomainFormat {}
3089
3090#[derive(Clone, Debug)]
3093pub enum EncoderSettings {
3094 Sbc(SbcEncoderSettings),
3095 Aac(AacEncoderSettings),
3096 H264(H264EncoderSettings),
3097 Hevc(HevcEncoderSettings),
3098 Cvsd(CvsdEncoderSettings),
3099 Lc3(Lc3EncoderSettings),
3100 Msbc(MSbcEncoderSettings),
3101 #[doc(hidden)]
3102 __SourceBreaking {
3103 unknown_ordinal: u64,
3104 },
3105}
3106
3107#[macro_export]
3109macro_rules! EncoderSettingsUnknown {
3110 () => {
3111 _
3112 };
3113}
3114
3115impl PartialEq for EncoderSettings {
3117 fn eq(&self, other: &Self) -> bool {
3118 match (self, other) {
3119 (Self::Sbc(x), Self::Sbc(y)) => *x == *y,
3120 (Self::Aac(x), Self::Aac(y)) => *x == *y,
3121 (Self::H264(x), Self::H264(y)) => *x == *y,
3122 (Self::Hevc(x), Self::Hevc(y)) => *x == *y,
3123 (Self::Cvsd(x), Self::Cvsd(y)) => *x == *y,
3124 (Self::Lc3(x), Self::Lc3(y)) => *x == *y,
3125 (Self::Msbc(x), Self::Msbc(y)) => *x == *y,
3126 _ => false,
3127 }
3128 }
3129}
3130
3131impl EncoderSettings {
3132 #[inline]
3133 pub fn ordinal(&self) -> u64 {
3134 match *self {
3135 Self::Sbc(_) => 1,
3136 Self::Aac(_) => 2,
3137 Self::H264(_) => 3,
3138 Self::Hevc(_) => 4,
3139 Self::Cvsd(_) => 5,
3140 Self::Lc3(_) => 6,
3141 Self::Msbc(_) => 7,
3142 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
3143 }
3144 }
3145
3146 #[inline]
3147 pub fn unknown_variant_for_testing() -> Self {
3148 Self::__SourceBreaking { unknown_ordinal: 0 }
3149 }
3150
3151 #[inline]
3152 pub fn is_unknown(&self) -> bool {
3153 match self {
3154 Self::__SourceBreaking { .. } => true,
3155 _ => false,
3156 }
3157 }
3158}
3159
3160impl fidl::Persistable for EncoderSettings {}
3161
3162#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
3164pub enum MediumSpecificStreamType {
3165 Audio(AudioStreamType),
3166 Video(VideoStreamType),
3167 Text(TextStreamType),
3168 Subpicture(SubpictureStreamType),
3169}
3170
3171impl MediumSpecificStreamType {
3172 #[inline]
3173 pub fn ordinal(&self) -> u64 {
3174 match *self {
3175 Self::Audio(_) => 1,
3176 Self::Video(_) => 2,
3177 Self::Text(_) => 3,
3178 Self::Subpicture(_) => 4,
3179 }
3180 }
3181}
3182
3183impl fidl::Persistable for MediumSpecificStreamType {}
3184
3185#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
3186pub enum Usage {
3187 RenderUsage(AudioRenderUsage),
3188 CaptureUsage(AudioCaptureUsage),
3189}
3190
3191impl Usage {
3192 #[inline]
3193 pub fn ordinal(&self) -> u64 {
3194 match *self {
3195 Self::RenderUsage(_) => 1,
3196 Self::CaptureUsage(_) => 2,
3197 }
3198 }
3199}
3200
3201impl fidl::Persistable for Usage {}
3202
3203#[derive(Clone, Debug)]
3204pub enum Usage2 {
3205 RenderUsage(AudioRenderUsage2),
3206 CaptureUsage(AudioCaptureUsage2),
3207 #[doc(hidden)]
3208 __SourceBreaking {
3209 unknown_ordinal: u64,
3210 },
3211}
3212
3213#[macro_export]
3215macro_rules! Usage2Unknown {
3216 () => {
3217 _
3218 };
3219}
3220
3221impl PartialEq for Usage2 {
3223 fn eq(&self, other: &Self) -> bool {
3224 match (self, other) {
3225 (Self::RenderUsage(x), Self::RenderUsage(y)) => *x == *y,
3226 (Self::CaptureUsage(x), Self::CaptureUsage(y)) => *x == *y,
3227 _ => false,
3228 }
3229 }
3230}
3231
3232impl Usage2 {
3233 #[inline]
3234 pub fn ordinal(&self) -> u64 {
3235 match *self {
3236 Self::RenderUsage(_) => 1,
3237 Self::CaptureUsage(_) => 2,
3238 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
3239 }
3240 }
3241
3242 #[inline]
3243 pub fn unknown_variant_for_testing() -> Self {
3244 Self::__SourceBreaking { unknown_ordinal: 0 }
3245 }
3246
3247 #[inline]
3248 pub fn is_unknown(&self) -> bool {
3249 match self {
3250 Self::__SourceBreaking { .. } => true,
3251 _ => false,
3252 }
3253 }
3254}
3255
3256impl fidl::Persistable for Usage2 {}
3257
3258#[derive(Clone, Debug)]
3260pub enum UsageState {
3261 Unadjusted(UsageStateUnadjusted),
3262 Ducked(UsageStateDucked),
3263 Muted(UsageStateMuted),
3264 #[doc(hidden)]
3265 __SourceBreaking {
3266 unknown_ordinal: u64,
3267 },
3268}
3269
3270#[macro_export]
3272macro_rules! UsageStateUnknown {
3273 () => {
3274 _
3275 };
3276}
3277
3278impl PartialEq for UsageState {
3280 fn eq(&self, other: &Self) -> bool {
3281 match (self, other) {
3282 (Self::Unadjusted(x), Self::Unadjusted(y)) => *x == *y,
3283 (Self::Ducked(x), Self::Ducked(y)) => *x == *y,
3284 (Self::Muted(x), Self::Muted(y)) => *x == *y,
3285 _ => false,
3286 }
3287 }
3288}
3289
3290impl UsageState {
3291 #[inline]
3292 pub fn ordinal(&self) -> u64 {
3293 match *self {
3294 Self::Unadjusted(_) => 1,
3295 Self::Ducked(_) => 2,
3296 Self::Muted(_) => 3,
3297 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
3298 }
3299 }
3300
3301 #[inline]
3302 pub fn unknown_variant_for_testing() -> Self {
3303 Self::__SourceBreaking { unknown_ordinal: 0 }
3304 }
3305
3306 #[inline]
3307 pub fn is_unknown(&self) -> bool {
3308 match self {
3309 Self::__SourceBreaking { .. } => true,
3310 _ => false,
3311 }
3312 }
3313}
3314
3315impl fidl::Persistable for UsageState {}
3316
3317#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
3321pub enum Value {
3322 BoolValue(bool),
3323 Uint64Value(u64),
3324 Int64Value(i64),
3325 StringValue(String),
3326 BytesValue(Vec<u8>),
3327}
3328
3329impl Value {
3330 #[inline]
3331 pub fn ordinal(&self) -> u64 {
3332 match *self {
3333 Self::BoolValue(_) => 1,
3334 Self::Uint64Value(_) => 2,
3335 Self::Int64Value(_) => 3,
3336 Self::StringValue(_) => 4,
3337 Self::BytesValue(_) => 5,
3338 }
3339 }
3340}
3341
3342impl fidl::Persistable for Value {}
3343
3344#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
3348pub enum VideoCompressedFormat {
3349 TempFieldTodoRemove(u32),
3350}
3351
3352impl VideoCompressedFormat {
3353 #[inline]
3354 pub fn ordinal(&self) -> u64 {
3355 match *self {
3356 Self::TempFieldTodoRemove(_) => 1,
3357 }
3358 }
3359}
3360
3361impl fidl::Persistable for VideoCompressedFormat {}
3362
3363#[derive(Clone, Debug, PartialEq)]
3369pub enum VideoFormat {
3370 Compressed(VideoCompressedFormat),
3371 Uncompressed(VideoUncompressedFormat),
3372}
3373
3374impl VideoFormat {
3375 #[inline]
3376 pub fn ordinal(&self) -> u64 {
3377 match *self {
3378 Self::Compressed(_) => 1,
3379 Self::Uncompressed(_) => 2,
3380 }
3381 }
3382}
3383
3384impl fidl::Persistable for VideoFormat {}
3385
3386pub mod activity_reporter_ordinals {
3387 pub const WATCH_RENDER_ACTIVITY: u64 = 0x2974e9f5880b2f1f;
3388 pub const WATCH_RENDER_ACTIVITY2: u64 = 0x484236fc11b363e6;
3389 pub const WATCH_CAPTURE_ACTIVITY: u64 = 0x70e7038e9658e128;
3390 pub const WATCH_CAPTURE_ACTIVITY2: u64 = 0x3d137e0364f9d550;
3391}
3392
3393pub mod audio_ordinals {
3394 pub const CREATE_AUDIO_RENDERER: u64 = 0x572f413566fd58f1;
3395 pub const CREATE_AUDIO_CAPTURER: u64 = 0x44660fc63a6202f;
3396}
3397
3398pub mod audio_capturer_ordinals {
3399 pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3400 pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3401 pub const ON_PACKET_PRODUCED: u64 = 0x6bbe69746a3c8bd9;
3402 pub const ON_END_OF_STREAM: u64 = 0x550e69b41d03e2c2;
3403 pub const RELEASE_PACKET: u64 = 0x7a7b57f0f7d9e4bb;
3404 pub const DISCARD_ALL_PACKETS: u64 = 0x27afd605e97b09d2;
3405 pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x35f9d721e905b831;
3406 pub const SET_PCM_STREAM_TYPE: u64 = 0x1531ea9ea2c852cd;
3407 pub const CAPTURE_AT: u64 = 0x784e25df72cea780;
3408 pub const START_ASYNC_CAPTURE: u64 = 0x7768adbb1ccfd7a6;
3409 pub const STOP_ASYNC_CAPTURE: u64 = 0x5bfc8790a8cef8cb;
3410 pub const STOP_ASYNC_CAPTURE_NO_REPLY: u64 = 0x33223cb2962c95e3;
3411 pub const BIND_GAIN_CONTROL: u64 = 0x658a6a17ddb3a8e0;
3412 pub const GET_REFERENCE_CLOCK: u64 = 0x50d037aa5a4b4d71;
3413 pub const SET_REFERENCE_CLOCK: u64 = 0x732b2c496d521bcf;
3414 pub const SET_USAGE: u64 = 0x42a16f392bd21b25;
3415 pub const SET_USAGE2: u64 = 0x7a73e251b8d2382b;
3416 pub const GET_STREAM_TYPE: u64 = 0x5dcaaa670b433088;
3417}
3418
3419pub mod audio_consumer_ordinals {
3420 pub const CREATE_STREAM_SINK: u64 = 0x525b3b97fdf7d884;
3421 pub const ON_END_OF_STREAM: u64 = 0x53a64e6d0e8f8a20;
3422 pub const START: u64 = 0x4fdbd44b3f2a3a3c;
3423 pub const STOP: u64 = 0x3d46c3741686c40d;
3424 pub const SET_RATE: u64 = 0x45342b73968bfafe;
3425 pub const BIND_VOLUME_CONTROL: u64 = 0x6f1b01fd887f5748;
3426 pub const WATCH_STATUS: u64 = 0x35cf702c721e2cc6;
3427}
3428
3429pub mod audio_core_ordinals {
3430 pub const CREATE_AUDIO_RENDERER: u64 = 0x2ac9beba47f83435;
3431 pub const CREATE_AUDIO_CAPTURER_WITH_CONFIGURATION: u64 = 0x459de383b0d76d97;
3432 pub const CREATE_AUDIO_CAPTURER: u64 = 0x787db169df99aed0;
3433 pub const ENABLE_DEVICE_SETTINGS: u64 = 0x41107a1917269b3e;
3434 pub const SET_RENDER_USAGE_GAIN: u64 = 0x48097f45f6e2b8e7;
3435 pub const SET_RENDER_USAGE_GAIN2: u64 = 0x779b1531dc9e64f4;
3436 pub const SET_CAPTURE_USAGE_GAIN: u64 = 0x457d29217d4ea248;
3437 pub const SET_CAPTURE_USAGE_GAIN2: u64 = 0x15065ee308f44af0;
3438 pub const BIND_USAGE_VOLUME_CONTROL: u64 = 0x7225be116aadc137;
3439 pub const BIND_USAGE_VOLUME_CONTROL2: u64 = 0x729dff93019d055;
3440 pub const GET_VOLUME_FROM_DB: u64 = 0x50e3ca45509770bf;
3441 pub const GET_VOLUME_FROM_DB2: u64 = 0x165c811091ef99da;
3442 pub const GET_DB_FROM_VOLUME: u64 = 0x3e8eec27dd5a8bda;
3443 pub const GET_DB_FROM_VOLUME2: u64 = 0x5f421a8ebf265bf3;
3444 pub const SET_INTERACTION: u64 = 0x7bfed14345ece7b7;
3445 pub const SET_INTERACTION2: u64 = 0x7226c7c6e6edc62f;
3446 pub const RESET_INTERACTIONS: u64 = 0x65bd94d9d0a28b5e;
3447 pub const LOAD_DEFAULTS: u64 = 0x54a0bebca85f6b31;
3448}
3449
3450pub mod audio_device_enumerator_ordinals {
3451 pub const GET_DEVICES: u64 = 0x4ce1aa218aeb12a6;
3452 pub const ON_DEVICE_ADDED: u64 = 0xe0fbe40057c4b44;
3453 pub const ON_DEVICE_REMOVED: u64 = 0x6f3b7574463d9ff8;
3454 pub const ON_DEVICE_GAIN_CHANGED: u64 = 0x14aefcbbb076b0e9;
3455 pub const ON_DEFAULT_DEVICE_CHANGED: u64 = 0x16357b42d4c16e11;
3456 pub const GET_DEVICE_GAIN: u64 = 0x25dd4723403c414b;
3457 pub const SET_DEVICE_GAIN: u64 = 0x5bdabc8ebe83591;
3458 pub const ADD_DEVICE_BY_CHANNEL: u64 = 0x72cdbada4d70ed67;
3459}
3460
3461pub mod audio_renderer_ordinals {
3462 pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3463 pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3464 pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3465 pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3466 pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3467 pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3468 pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3469 pub const BIND_GAIN_CONTROL: u64 = 0x293f5c7f8fba2bdc;
3470 pub const SET_PTS_UNITS: u64 = 0xf68cd108785a27c;
3471 pub const SET_PTS_CONTINUITY_THRESHOLD: u64 = 0x2849ba571d1971ba;
3472 pub const GET_REFERENCE_CLOCK: u64 = 0x2f7a7f011a172f7e;
3473 pub const SET_REFERENCE_CLOCK: u64 = 0x39acd05d832b5fed;
3474 pub const SET_USAGE: u64 = 0x3994bd23b55a733e;
3475 pub const SET_USAGE2: u64 = 0x2904035c7132b103;
3476 pub const SET_PCM_STREAM_TYPE: u64 = 0x27aa715d8901fa19;
3477 pub const ENABLE_MIN_LEAD_TIME_EVENTS: u64 = 0x62808dfad72bf890;
3478 pub const ON_MIN_LEAD_TIME_CHANGED: u64 = 0x4feff7d278978c4e;
3479 pub const GET_MIN_LEAD_TIME: u64 = 0x1cf3c3ecd8fec26b;
3480 pub const PLAY: u64 = 0x3c0162db084f74a3;
3481 pub const PLAY_NO_REPLY: u64 = 0x1b7fe832b68c22ef;
3482 pub const PAUSE: u64 = 0x41d557588d93d153;
3483 pub const PAUSE_NO_REPLY: u64 = 0x24cc45d4f3855ab;
3484}
3485
3486pub mod profile_provider_ordinals {
3487 pub const REGISTER_HANDLER_WITH_CAPACITY: u64 = 0x60459ecef7458176;
3488 pub const UNREGISTER_HANDLER: u64 = 0x724d9d5fd8ef544c;
3489 pub const REGISTER_MEMORY_RANGE: u64 = 0x2f509d3523e9562d;
3490 pub const UNREGISTER_MEMORY_RANGE: u64 = 0x2dc313d6aa81ad27;
3491}
3492
3493pub mod session_audio_consumer_factory_ordinals {
3494 pub const CREATE_AUDIO_CONSUMER: u64 = 0x6fab96f988e7d7fb;
3495}
3496
3497pub mod simple_stream_sink_ordinals {
3498 pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3499 pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3500 pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3501 pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3502 pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3503 pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3504 pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3505}
3506
3507pub mod stream_buffer_set_ordinals {
3508 pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3509 pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3510}
3511
3512pub mod stream_processor_ordinals {
3513 pub const ENABLE_ON_STREAM_FAILED: u64 = 0x3940929617dbf02b;
3514 pub const ON_STREAM_FAILED: u64 = 0x77ccf70bb061cf8e;
3515 pub const ON_INPUT_CONSTRAINTS: u64 = 0x211da9966a8ca0;
3516 pub const SET_INPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0xb02e0663a40e4c4;
3517 pub const ON_OUTPUT_CONSTRAINTS: u64 = 0x40d8234504c170f3;
3518 pub const ON_OUTPUT_FORMAT: u64 = 0x131b77ae120360bc;
3519 pub const SET_OUTPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0x118bb8c819a7bbbb;
3520 pub const COMPLETE_OUTPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0x50529e5c680ae3ab;
3521 pub const FLUSH_END_OF_STREAM_AND_CLOSE_STREAM: u64 = 0x2b62c3e26d0667e6;
3522 pub const CLOSE_CURRENT_STREAM: u64 = 0x1d8a67522170ca07;
3523 pub const SYNC: u64 = 0x4b3e44300b0ec6aa;
3524 pub const ON_OUTPUT_PACKET: u64 = 0x5c2029be1090ce93;
3525 pub const RECYCLE_OUTPUT_PACKET: u64 = 0x32763632b94e0bd5;
3526 pub const ON_OUTPUT_END_OF_STREAM: u64 = 0x3bb65d237cfa50e6;
3527 pub const QUEUE_INPUT_FORMAT_DETAILS: u64 = 0x170dc0979d52231;
3528 pub const QUEUE_INPUT_PACKET: u64 = 0x47173d2652d9df3b;
3529 pub const ON_FREE_INPUT_PACKET: u64 = 0xeef799b28708bbd;
3530 pub const QUEUE_INPUT_END_OF_STREAM: u64 = 0x2051b6ad00f20b37;
3531}
3532
3533pub mod stream_sink_ordinals {
3534 pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3535 pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3536 pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3537 pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3538 pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3539}
3540
3541pub mod stream_source_ordinals {
3542 pub const ON_PACKET_PRODUCED: u64 = 0x6bbe69746a3c8bd9;
3543 pub const ON_END_OF_STREAM: u64 = 0x550e69b41d03e2c2;
3544 pub const RELEASE_PACKET: u64 = 0x7a7b57f0f7d9e4bb;
3545 pub const DISCARD_ALL_PACKETS: u64 = 0x27afd605e97b09d2;
3546 pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x35f9d721e905b831;
3547}
3548
3549pub mod usage2_audio_consumer_factory_ordinals {
3550 pub const CREATE_AUDIO_CONSUMER: u64 = 0x767722302a171873;
3551}
3552
3553pub mod usage_audio_consumer_factory_ordinals {
3554 pub const CREATE_AUDIO_CONSUMER: u64 = 0x4d975ca9b8f625a3;
3555}
3556
3557pub mod usage_gain_listener_ordinals {
3558 pub const ON_GAIN_MUTE_CHANGED: u64 = 0x681570258eac3a8d;
3559}
3560
3561pub mod usage_gain_reporter_ordinals {
3562 pub const REGISTER_LISTENER: u64 = 0x767107c168c226af;
3563 pub const REGISTER_LISTENER2: u64 = 0x760a8e1c5873629c;
3564}
3565
3566pub mod usage_reporter_ordinals {
3567 pub const WATCH: u64 = 0x769e6fb17075c959;
3568 pub const WATCH2: u64 = 0x4a43c4c82f5d8ce8;
3569}
3570
3571pub mod usage_watcher_ordinals {
3572 pub const ON_STATE_CHANGED: u64 = 0x5b955c5768ec75c5;
3573}
3574
3575pub mod usage_watcher2_ordinals {
3576 pub const ON_STATE_CHANGED: u64 = 0xca31a8b13c324d4;
3577}
3578
3579mod internal {
3580 use super::*;
3581 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartFlags {
3582 type Owned = Self;
3583
3584 #[inline(always)]
3585 fn inline_align(_context: fidl::encoding::Context) -> usize {
3586 4
3587 }
3588
3589 #[inline(always)]
3590 fn inline_size(_context: fidl::encoding::Context) -> usize {
3591 4
3592 }
3593 }
3594
3595 impl fidl::encoding::ValueTypeMarker for AudioConsumerStartFlags {
3596 type Borrowed<'a> = Self;
3597 #[inline(always)]
3598 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3599 *value
3600 }
3601 }
3602
3603 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3604 for AudioConsumerStartFlags
3605 {
3606 #[inline]
3607 unsafe fn encode(
3608 self,
3609 encoder: &mut fidl::encoding::Encoder<'_, D>,
3610 offset: usize,
3611 _depth: fidl::encoding::Depth,
3612 ) -> fidl::Result<()> {
3613 encoder.debug_check_bounds::<Self>(offset);
3614 if self.bits() & Self::all().bits() != self.bits() {
3615 return Err(fidl::Error::InvalidBitsValue);
3616 }
3617 encoder.write_num(self.bits(), offset);
3618 Ok(())
3619 }
3620 }
3621
3622 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3623 for AudioConsumerStartFlags
3624 {
3625 #[inline(always)]
3626 fn new_empty() -> Self {
3627 Self::empty()
3628 }
3629
3630 #[inline]
3631 unsafe fn decode(
3632 &mut self,
3633 decoder: &mut fidl::encoding::Decoder<'_, D>,
3634 offset: usize,
3635 _depth: fidl::encoding::Depth,
3636 ) -> fidl::Result<()> {
3637 decoder.debug_check_bounds::<Self>(offset);
3638 let prim = decoder.read_num::<u32>(offset);
3639 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3640 Ok(())
3641 }
3642 }
3643 unsafe impl fidl::encoding::TypeMarker for AudioGainInfoFlags {
3644 type Owned = Self;
3645
3646 #[inline(always)]
3647 fn inline_align(_context: fidl::encoding::Context) -> usize {
3648 4
3649 }
3650
3651 #[inline(always)]
3652 fn inline_size(_context: fidl::encoding::Context) -> usize {
3653 4
3654 }
3655 }
3656
3657 impl fidl::encoding::ValueTypeMarker for AudioGainInfoFlags {
3658 type Borrowed<'a> = Self;
3659 #[inline(always)]
3660 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3661 *value
3662 }
3663 }
3664
3665 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3666 for AudioGainInfoFlags
3667 {
3668 #[inline]
3669 unsafe fn encode(
3670 self,
3671 encoder: &mut fidl::encoding::Encoder<'_, D>,
3672 offset: usize,
3673 _depth: fidl::encoding::Depth,
3674 ) -> fidl::Result<()> {
3675 encoder.debug_check_bounds::<Self>(offset);
3676 if self.bits() & Self::all().bits() != self.bits() {
3677 return Err(fidl::Error::InvalidBitsValue);
3678 }
3679 encoder.write_num(self.bits(), offset);
3680 Ok(())
3681 }
3682 }
3683
3684 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfoFlags {
3685 #[inline(always)]
3686 fn new_empty() -> Self {
3687 Self::empty()
3688 }
3689
3690 #[inline]
3691 unsafe fn decode(
3692 &mut self,
3693 decoder: &mut fidl::encoding::Decoder<'_, D>,
3694 offset: usize,
3695 _depth: fidl::encoding::Depth,
3696 ) -> fidl::Result<()> {
3697 decoder.debug_check_bounds::<Self>(offset);
3698 let prim = decoder.read_num::<u32>(offset);
3699 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3700 Ok(())
3701 }
3702 }
3703 unsafe impl fidl::encoding::TypeMarker for AudioGainValidFlags {
3704 type Owned = Self;
3705
3706 #[inline(always)]
3707 fn inline_align(_context: fidl::encoding::Context) -> usize {
3708 4
3709 }
3710
3711 #[inline(always)]
3712 fn inline_size(_context: fidl::encoding::Context) -> usize {
3713 4
3714 }
3715 }
3716
3717 impl fidl::encoding::ValueTypeMarker for AudioGainValidFlags {
3718 type Borrowed<'a> = Self;
3719 #[inline(always)]
3720 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3721 *value
3722 }
3723 }
3724
3725 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3726 for AudioGainValidFlags
3727 {
3728 #[inline]
3729 unsafe fn encode(
3730 self,
3731 encoder: &mut fidl::encoding::Encoder<'_, D>,
3732 offset: usize,
3733 _depth: fidl::encoding::Depth,
3734 ) -> fidl::Result<()> {
3735 encoder.debug_check_bounds::<Self>(offset);
3736 if self.bits() & Self::all().bits() != self.bits() {
3737 return Err(fidl::Error::InvalidBitsValue);
3738 }
3739 encoder.write_num(self.bits(), offset);
3740 Ok(())
3741 }
3742 }
3743
3744 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainValidFlags {
3745 #[inline(always)]
3746 fn new_empty() -> Self {
3747 Self::empty()
3748 }
3749
3750 #[inline]
3751 unsafe fn decode(
3752 &mut self,
3753 decoder: &mut fidl::encoding::Decoder<'_, D>,
3754 offset: usize,
3755 _depth: fidl::encoding::Depth,
3756 ) -> fidl::Result<()> {
3757 decoder.debug_check_bounds::<Self>(offset);
3758 let prim = decoder.read_num::<u32>(offset);
3759 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3760 Ok(())
3761 }
3762 }
3763 unsafe impl fidl::encoding::TypeMarker for AacAudioObjectType {
3764 type Owned = Self;
3765
3766 #[inline(always)]
3767 fn inline_align(_context: fidl::encoding::Context) -> usize {
3768 std::mem::align_of::<u32>()
3769 }
3770
3771 #[inline(always)]
3772 fn inline_size(_context: fidl::encoding::Context) -> usize {
3773 std::mem::size_of::<u32>()
3774 }
3775
3776 #[inline(always)]
3777 fn encode_is_copy() -> bool {
3778 true
3779 }
3780
3781 #[inline(always)]
3782 fn decode_is_copy() -> bool {
3783 false
3784 }
3785 }
3786
3787 impl fidl::encoding::ValueTypeMarker for AacAudioObjectType {
3788 type Borrowed<'a> = Self;
3789 #[inline(always)]
3790 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3791 *value
3792 }
3793 }
3794
3795 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3796 for AacAudioObjectType
3797 {
3798 #[inline]
3799 unsafe fn encode(
3800 self,
3801 encoder: &mut fidl::encoding::Encoder<'_, D>,
3802 offset: usize,
3803 _depth: fidl::encoding::Depth,
3804 ) -> fidl::Result<()> {
3805 encoder.debug_check_bounds::<Self>(offset);
3806 encoder.write_num(self.into_primitive(), offset);
3807 Ok(())
3808 }
3809 }
3810
3811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacAudioObjectType {
3812 #[inline(always)]
3813 fn new_empty() -> Self {
3814 Self::Mpeg2AacLc
3815 }
3816
3817 #[inline]
3818 unsafe fn decode(
3819 &mut self,
3820 decoder: &mut fidl::encoding::Decoder<'_, D>,
3821 offset: usize,
3822 _depth: fidl::encoding::Depth,
3823 ) -> fidl::Result<()> {
3824 decoder.debug_check_bounds::<Self>(offset);
3825 let prim = decoder.read_num::<u32>(offset);
3826
3827 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3828 Ok(())
3829 }
3830 }
3831 unsafe impl fidl::encoding::TypeMarker for AacChannelMode {
3832 type Owned = Self;
3833
3834 #[inline(always)]
3835 fn inline_align(_context: fidl::encoding::Context) -> usize {
3836 std::mem::align_of::<u32>()
3837 }
3838
3839 #[inline(always)]
3840 fn inline_size(_context: fidl::encoding::Context) -> usize {
3841 std::mem::size_of::<u32>()
3842 }
3843
3844 #[inline(always)]
3845 fn encode_is_copy() -> bool {
3846 true
3847 }
3848
3849 #[inline(always)]
3850 fn decode_is_copy() -> bool {
3851 false
3852 }
3853 }
3854
3855 impl fidl::encoding::ValueTypeMarker for AacChannelMode {
3856 type Borrowed<'a> = Self;
3857 #[inline(always)]
3858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3859 *value
3860 }
3861 }
3862
3863 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AacChannelMode {
3864 #[inline]
3865 unsafe fn encode(
3866 self,
3867 encoder: &mut fidl::encoding::Encoder<'_, D>,
3868 offset: usize,
3869 _depth: fidl::encoding::Depth,
3870 ) -> fidl::Result<()> {
3871 encoder.debug_check_bounds::<Self>(offset);
3872 encoder.write_num(self.into_primitive(), offset);
3873 Ok(())
3874 }
3875 }
3876
3877 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacChannelMode {
3878 #[inline(always)]
3879 fn new_empty() -> Self {
3880 Self::Mono
3881 }
3882
3883 #[inline]
3884 unsafe fn decode(
3885 &mut self,
3886 decoder: &mut fidl::encoding::Decoder<'_, D>,
3887 offset: usize,
3888 _depth: fidl::encoding::Depth,
3889 ) -> fidl::Result<()> {
3890 decoder.debug_check_bounds::<Self>(offset);
3891 let prim = decoder.read_num::<u32>(offset);
3892
3893 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3894 Ok(())
3895 }
3896 }
3897 unsafe impl fidl::encoding::TypeMarker for AacVariableBitRate {
3898 type Owned = Self;
3899
3900 #[inline(always)]
3901 fn inline_align(_context: fidl::encoding::Context) -> usize {
3902 std::mem::align_of::<u32>()
3903 }
3904
3905 #[inline(always)]
3906 fn inline_size(_context: fidl::encoding::Context) -> usize {
3907 std::mem::size_of::<u32>()
3908 }
3909
3910 #[inline(always)]
3911 fn encode_is_copy() -> bool {
3912 true
3913 }
3914
3915 #[inline(always)]
3916 fn decode_is_copy() -> bool {
3917 false
3918 }
3919 }
3920
3921 impl fidl::encoding::ValueTypeMarker for AacVariableBitRate {
3922 type Borrowed<'a> = Self;
3923 #[inline(always)]
3924 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3925 *value
3926 }
3927 }
3928
3929 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3930 for AacVariableBitRate
3931 {
3932 #[inline]
3933 unsafe fn encode(
3934 self,
3935 encoder: &mut fidl::encoding::Encoder<'_, D>,
3936 offset: usize,
3937 _depth: fidl::encoding::Depth,
3938 ) -> fidl::Result<()> {
3939 encoder.debug_check_bounds::<Self>(offset);
3940 encoder.write_num(self.into_primitive(), offset);
3941 Ok(())
3942 }
3943 }
3944
3945 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacVariableBitRate {
3946 #[inline(always)]
3947 fn new_empty() -> Self {
3948 Self::V1
3949 }
3950
3951 #[inline]
3952 unsafe fn decode(
3953 &mut self,
3954 decoder: &mut fidl::encoding::Decoder<'_, D>,
3955 offset: usize,
3956 _depth: fidl::encoding::Depth,
3957 ) -> fidl::Result<()> {
3958 decoder.debug_check_bounds::<Self>(offset);
3959 let prim = decoder.read_num::<u32>(offset);
3960
3961 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3962 Ok(())
3963 }
3964 }
3965 unsafe impl fidl::encoding::TypeMarker for AudioBitrateMode {
3966 type Owned = Self;
3967
3968 #[inline(always)]
3969 fn inline_align(_context: fidl::encoding::Context) -> usize {
3970 std::mem::align_of::<u32>()
3971 }
3972
3973 #[inline(always)]
3974 fn inline_size(_context: fidl::encoding::Context) -> usize {
3975 std::mem::size_of::<u32>()
3976 }
3977
3978 #[inline(always)]
3979 fn encode_is_copy() -> bool {
3980 true
3981 }
3982
3983 #[inline(always)]
3984 fn decode_is_copy() -> bool {
3985 false
3986 }
3987 }
3988
3989 impl fidl::encoding::ValueTypeMarker for AudioBitrateMode {
3990 type Borrowed<'a> = Self;
3991 #[inline(always)]
3992 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3993 *value
3994 }
3995 }
3996
3997 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3998 for AudioBitrateMode
3999 {
4000 #[inline]
4001 unsafe fn encode(
4002 self,
4003 encoder: &mut fidl::encoding::Encoder<'_, D>,
4004 offset: usize,
4005 _depth: fidl::encoding::Depth,
4006 ) -> fidl::Result<()> {
4007 encoder.debug_check_bounds::<Self>(offset);
4008 encoder.write_num(self.into_primitive(), offset);
4009 Ok(())
4010 }
4011 }
4012
4013 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioBitrateMode {
4014 #[inline(always)]
4015 fn new_empty() -> Self {
4016 Self::Unspecified
4017 }
4018
4019 #[inline]
4020 unsafe fn decode(
4021 &mut self,
4022 decoder: &mut fidl::encoding::Decoder<'_, D>,
4023 offset: usize,
4024 _depth: fidl::encoding::Depth,
4025 ) -> fidl::Result<()> {
4026 decoder.debug_check_bounds::<Self>(offset);
4027 let prim = decoder.read_num::<u32>(offset);
4028
4029 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4030 Ok(())
4031 }
4032 }
4033 unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage {
4034 type Owned = Self;
4035
4036 #[inline(always)]
4037 fn inline_align(_context: fidl::encoding::Context) -> usize {
4038 std::mem::align_of::<u32>()
4039 }
4040
4041 #[inline(always)]
4042 fn inline_size(_context: fidl::encoding::Context) -> usize {
4043 std::mem::size_of::<u32>()
4044 }
4045
4046 #[inline(always)]
4047 fn encode_is_copy() -> bool {
4048 true
4049 }
4050
4051 #[inline(always)]
4052 fn decode_is_copy() -> bool {
4053 false
4054 }
4055 }
4056
4057 impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage {
4058 type Borrowed<'a> = Self;
4059 #[inline(always)]
4060 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4061 *value
4062 }
4063 }
4064
4065 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4066 for AudioCaptureUsage
4067 {
4068 #[inline]
4069 unsafe fn encode(
4070 self,
4071 encoder: &mut fidl::encoding::Encoder<'_, D>,
4072 offset: usize,
4073 _depth: fidl::encoding::Depth,
4074 ) -> fidl::Result<()> {
4075 encoder.debug_check_bounds::<Self>(offset);
4076 encoder.write_num(self.into_primitive(), offset);
4077 Ok(())
4078 }
4079 }
4080
4081 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage {
4082 #[inline(always)]
4083 fn new_empty() -> Self {
4084 Self::Background
4085 }
4086
4087 #[inline]
4088 unsafe fn decode(
4089 &mut self,
4090 decoder: &mut fidl::encoding::Decoder<'_, D>,
4091 offset: usize,
4092 _depth: fidl::encoding::Depth,
4093 ) -> fidl::Result<()> {
4094 decoder.debug_check_bounds::<Self>(offset);
4095 let prim = decoder.read_num::<u32>(offset);
4096
4097 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4098 Ok(())
4099 }
4100 }
4101 unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage2 {
4102 type Owned = Self;
4103
4104 #[inline(always)]
4105 fn inline_align(_context: fidl::encoding::Context) -> usize {
4106 std::mem::align_of::<u32>()
4107 }
4108
4109 #[inline(always)]
4110 fn inline_size(_context: fidl::encoding::Context) -> usize {
4111 std::mem::size_of::<u32>()
4112 }
4113
4114 #[inline(always)]
4115 fn encode_is_copy() -> bool {
4116 false
4117 }
4118
4119 #[inline(always)]
4120 fn decode_is_copy() -> bool {
4121 false
4122 }
4123 }
4124
4125 impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage2 {
4126 type Borrowed<'a> = Self;
4127 #[inline(always)]
4128 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4129 *value
4130 }
4131 }
4132
4133 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4134 for AudioCaptureUsage2
4135 {
4136 #[inline]
4137 unsafe fn encode(
4138 self,
4139 encoder: &mut fidl::encoding::Encoder<'_, D>,
4140 offset: usize,
4141 _depth: fidl::encoding::Depth,
4142 ) -> fidl::Result<()> {
4143 encoder.debug_check_bounds::<Self>(offset);
4144 encoder.write_num(self.into_primitive(), offset);
4145 Ok(())
4146 }
4147 }
4148
4149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage2 {
4150 #[inline(always)]
4151 fn new_empty() -> Self {
4152 Self::unknown()
4153 }
4154
4155 #[inline]
4156 unsafe fn decode(
4157 &mut self,
4158 decoder: &mut fidl::encoding::Decoder<'_, D>,
4159 offset: usize,
4160 _depth: fidl::encoding::Depth,
4161 ) -> fidl::Result<()> {
4162 decoder.debug_check_bounds::<Self>(offset);
4163 let prim = decoder.read_num::<u32>(offset);
4164
4165 *self = Self::from_primitive_allow_unknown(prim);
4166 Ok(())
4167 }
4168 }
4169 unsafe impl fidl::encoding::TypeMarker for AudioChannelId {
4170 type Owned = Self;
4171
4172 #[inline(always)]
4173 fn inline_align(_context: fidl::encoding::Context) -> usize {
4174 std::mem::align_of::<u32>()
4175 }
4176
4177 #[inline(always)]
4178 fn inline_size(_context: fidl::encoding::Context) -> usize {
4179 std::mem::size_of::<u32>()
4180 }
4181
4182 #[inline(always)]
4183 fn encode_is_copy() -> bool {
4184 true
4185 }
4186
4187 #[inline(always)]
4188 fn decode_is_copy() -> bool {
4189 false
4190 }
4191 }
4192
4193 impl fidl::encoding::ValueTypeMarker for AudioChannelId {
4194 type Borrowed<'a> = Self;
4195 #[inline(always)]
4196 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4197 *value
4198 }
4199 }
4200
4201 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioChannelId {
4202 #[inline]
4203 unsafe fn encode(
4204 self,
4205 encoder: &mut fidl::encoding::Encoder<'_, D>,
4206 offset: usize,
4207 _depth: fidl::encoding::Depth,
4208 ) -> fidl::Result<()> {
4209 encoder.debug_check_bounds::<Self>(offset);
4210 encoder.write_num(self.into_primitive(), offset);
4211 Ok(())
4212 }
4213 }
4214
4215 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioChannelId {
4216 #[inline(always)]
4217 fn new_empty() -> Self {
4218 Self::Skip
4219 }
4220
4221 #[inline]
4222 unsafe fn decode(
4223 &mut self,
4224 decoder: &mut fidl::encoding::Decoder<'_, D>,
4225 offset: usize,
4226 _depth: fidl::encoding::Depth,
4227 ) -> fidl::Result<()> {
4228 decoder.debug_check_bounds::<Self>(offset);
4229 let prim = decoder.read_num::<u32>(offset);
4230
4231 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4232 Ok(())
4233 }
4234 }
4235 unsafe impl fidl::encoding::TypeMarker for AudioOutputRoutingPolicy {
4236 type Owned = Self;
4237
4238 #[inline(always)]
4239 fn inline_align(_context: fidl::encoding::Context) -> usize {
4240 std::mem::align_of::<u32>()
4241 }
4242
4243 #[inline(always)]
4244 fn inline_size(_context: fidl::encoding::Context) -> usize {
4245 std::mem::size_of::<u32>()
4246 }
4247
4248 #[inline(always)]
4249 fn encode_is_copy() -> bool {
4250 true
4251 }
4252
4253 #[inline(always)]
4254 fn decode_is_copy() -> bool {
4255 false
4256 }
4257 }
4258
4259 impl fidl::encoding::ValueTypeMarker for AudioOutputRoutingPolicy {
4260 type Borrowed<'a> = Self;
4261 #[inline(always)]
4262 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4263 *value
4264 }
4265 }
4266
4267 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4268 for AudioOutputRoutingPolicy
4269 {
4270 #[inline]
4271 unsafe fn encode(
4272 self,
4273 encoder: &mut fidl::encoding::Encoder<'_, D>,
4274 offset: usize,
4275 _depth: fidl::encoding::Depth,
4276 ) -> fidl::Result<()> {
4277 encoder.debug_check_bounds::<Self>(offset);
4278 encoder.write_num(self.into_primitive(), offset);
4279 Ok(())
4280 }
4281 }
4282
4283 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4284 for AudioOutputRoutingPolicy
4285 {
4286 #[inline(always)]
4287 fn new_empty() -> Self {
4288 Self::AllPluggedOutputs
4289 }
4290
4291 #[inline]
4292 unsafe fn decode(
4293 &mut self,
4294 decoder: &mut fidl::encoding::Decoder<'_, D>,
4295 offset: usize,
4296 _depth: fidl::encoding::Depth,
4297 ) -> fidl::Result<()> {
4298 decoder.debug_check_bounds::<Self>(offset);
4299 let prim = decoder.read_num::<u32>(offset);
4300
4301 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4302 Ok(())
4303 }
4304 }
4305 unsafe impl fidl::encoding::TypeMarker for AudioPcmMode {
4306 type Owned = Self;
4307
4308 #[inline(always)]
4309 fn inline_align(_context: fidl::encoding::Context) -> usize {
4310 std::mem::align_of::<u32>()
4311 }
4312
4313 #[inline(always)]
4314 fn inline_size(_context: fidl::encoding::Context) -> usize {
4315 std::mem::size_of::<u32>()
4316 }
4317
4318 #[inline(always)]
4319 fn encode_is_copy() -> bool {
4320 true
4321 }
4322
4323 #[inline(always)]
4324 fn decode_is_copy() -> bool {
4325 false
4326 }
4327 }
4328
4329 impl fidl::encoding::ValueTypeMarker for AudioPcmMode {
4330 type Borrowed<'a> = Self;
4331 #[inline(always)]
4332 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4333 *value
4334 }
4335 }
4336
4337 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioPcmMode {
4338 #[inline]
4339 unsafe fn encode(
4340 self,
4341 encoder: &mut fidl::encoding::Encoder<'_, D>,
4342 offset: usize,
4343 _depth: fidl::encoding::Depth,
4344 ) -> fidl::Result<()> {
4345 encoder.debug_check_bounds::<Self>(offset);
4346 encoder.write_num(self.into_primitive(), offset);
4347 Ok(())
4348 }
4349 }
4350
4351 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioPcmMode {
4352 #[inline(always)]
4353 fn new_empty() -> Self {
4354 Self::Linear
4355 }
4356
4357 #[inline]
4358 unsafe fn decode(
4359 &mut self,
4360 decoder: &mut fidl::encoding::Decoder<'_, D>,
4361 offset: usize,
4362 _depth: fidl::encoding::Depth,
4363 ) -> fidl::Result<()> {
4364 decoder.debug_check_bounds::<Self>(offset);
4365 let prim = decoder.read_num::<u32>(offset);
4366
4367 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4368 Ok(())
4369 }
4370 }
4371 unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage {
4372 type Owned = Self;
4373
4374 #[inline(always)]
4375 fn inline_align(_context: fidl::encoding::Context) -> usize {
4376 std::mem::align_of::<u32>()
4377 }
4378
4379 #[inline(always)]
4380 fn inline_size(_context: fidl::encoding::Context) -> usize {
4381 std::mem::size_of::<u32>()
4382 }
4383
4384 #[inline(always)]
4385 fn encode_is_copy() -> bool {
4386 true
4387 }
4388
4389 #[inline(always)]
4390 fn decode_is_copy() -> bool {
4391 false
4392 }
4393 }
4394
4395 impl fidl::encoding::ValueTypeMarker for AudioRenderUsage {
4396 type Borrowed<'a> = Self;
4397 #[inline(always)]
4398 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4399 *value
4400 }
4401 }
4402
4403 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4404 for AudioRenderUsage
4405 {
4406 #[inline]
4407 unsafe fn encode(
4408 self,
4409 encoder: &mut fidl::encoding::Encoder<'_, D>,
4410 offset: usize,
4411 _depth: fidl::encoding::Depth,
4412 ) -> fidl::Result<()> {
4413 encoder.debug_check_bounds::<Self>(offset);
4414 encoder.write_num(self.into_primitive(), offset);
4415 Ok(())
4416 }
4417 }
4418
4419 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage {
4420 #[inline(always)]
4421 fn new_empty() -> Self {
4422 Self::Background
4423 }
4424
4425 #[inline]
4426 unsafe fn decode(
4427 &mut self,
4428 decoder: &mut fidl::encoding::Decoder<'_, D>,
4429 offset: usize,
4430 _depth: fidl::encoding::Depth,
4431 ) -> fidl::Result<()> {
4432 decoder.debug_check_bounds::<Self>(offset);
4433 let prim = decoder.read_num::<u32>(offset);
4434
4435 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4436 Ok(())
4437 }
4438 }
4439 unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage2 {
4440 type Owned = Self;
4441
4442 #[inline(always)]
4443 fn inline_align(_context: fidl::encoding::Context) -> usize {
4444 std::mem::align_of::<u32>()
4445 }
4446
4447 #[inline(always)]
4448 fn inline_size(_context: fidl::encoding::Context) -> usize {
4449 std::mem::size_of::<u32>()
4450 }
4451
4452 #[inline(always)]
4453 fn encode_is_copy() -> bool {
4454 false
4455 }
4456
4457 #[inline(always)]
4458 fn decode_is_copy() -> bool {
4459 false
4460 }
4461 }
4462
4463 impl fidl::encoding::ValueTypeMarker for AudioRenderUsage2 {
4464 type Borrowed<'a> = Self;
4465 #[inline(always)]
4466 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4467 *value
4468 }
4469 }
4470
4471 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4472 for AudioRenderUsage2
4473 {
4474 #[inline]
4475 unsafe fn encode(
4476 self,
4477 encoder: &mut fidl::encoding::Encoder<'_, D>,
4478 offset: usize,
4479 _depth: fidl::encoding::Depth,
4480 ) -> fidl::Result<()> {
4481 encoder.debug_check_bounds::<Self>(offset);
4482 encoder.write_num(self.into_primitive(), offset);
4483 Ok(())
4484 }
4485 }
4486
4487 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage2 {
4488 #[inline(always)]
4489 fn new_empty() -> Self {
4490 Self::unknown()
4491 }
4492
4493 #[inline]
4494 unsafe fn decode(
4495 &mut self,
4496 decoder: &mut fidl::encoding::Decoder<'_, D>,
4497 offset: usize,
4498 _depth: fidl::encoding::Depth,
4499 ) -> fidl::Result<()> {
4500 decoder.debug_check_bounds::<Self>(offset);
4501 let prim = decoder.read_num::<u32>(offset);
4502
4503 *self = Self::from_primitive_allow_unknown(prim);
4504 Ok(())
4505 }
4506 }
4507 unsafe impl fidl::encoding::TypeMarker for AudioSampleFormat {
4508 type Owned = Self;
4509
4510 #[inline(always)]
4511 fn inline_align(_context: fidl::encoding::Context) -> usize {
4512 std::mem::align_of::<u32>()
4513 }
4514
4515 #[inline(always)]
4516 fn inline_size(_context: fidl::encoding::Context) -> usize {
4517 std::mem::size_of::<u32>()
4518 }
4519
4520 #[inline(always)]
4521 fn encode_is_copy() -> bool {
4522 true
4523 }
4524
4525 #[inline(always)]
4526 fn decode_is_copy() -> bool {
4527 false
4528 }
4529 }
4530
4531 impl fidl::encoding::ValueTypeMarker for AudioSampleFormat {
4532 type Borrowed<'a> = Self;
4533 #[inline(always)]
4534 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4535 *value
4536 }
4537 }
4538
4539 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4540 for AudioSampleFormat
4541 {
4542 #[inline]
4543 unsafe fn encode(
4544 self,
4545 encoder: &mut fidl::encoding::Encoder<'_, D>,
4546 offset: usize,
4547 _depth: fidl::encoding::Depth,
4548 ) -> fidl::Result<()> {
4549 encoder.debug_check_bounds::<Self>(offset);
4550 encoder.write_num(self.into_primitive(), offset);
4551 Ok(())
4552 }
4553 }
4554
4555 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioSampleFormat {
4556 #[inline(always)]
4557 fn new_empty() -> Self {
4558 Self::Unsigned8
4559 }
4560
4561 #[inline]
4562 unsafe fn decode(
4563 &mut self,
4564 decoder: &mut fidl::encoding::Decoder<'_, D>,
4565 offset: usize,
4566 _depth: fidl::encoding::Depth,
4567 ) -> fidl::Result<()> {
4568 decoder.debug_check_bounds::<Self>(offset);
4569 let prim = decoder.read_num::<u32>(offset);
4570
4571 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4572 Ok(())
4573 }
4574 }
4575 unsafe impl fidl::encoding::TypeMarker for Behavior {
4576 type Owned = Self;
4577
4578 #[inline(always)]
4579 fn inline_align(_context: fidl::encoding::Context) -> usize {
4580 std::mem::align_of::<u32>()
4581 }
4582
4583 #[inline(always)]
4584 fn inline_size(_context: fidl::encoding::Context) -> usize {
4585 std::mem::size_of::<u32>()
4586 }
4587
4588 #[inline(always)]
4589 fn encode_is_copy() -> bool {
4590 false
4591 }
4592
4593 #[inline(always)]
4594 fn decode_is_copy() -> bool {
4595 false
4596 }
4597 }
4598
4599 impl fidl::encoding::ValueTypeMarker for Behavior {
4600 type Borrowed<'a> = Self;
4601 #[inline(always)]
4602 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4603 *value
4604 }
4605 }
4606
4607 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Behavior {
4608 #[inline]
4609 unsafe fn encode(
4610 self,
4611 encoder: &mut fidl::encoding::Encoder<'_, D>,
4612 offset: usize,
4613 _depth: fidl::encoding::Depth,
4614 ) -> fidl::Result<()> {
4615 encoder.debug_check_bounds::<Self>(offset);
4616 encoder.write_num(self.into_primitive(), offset);
4617 Ok(())
4618 }
4619 }
4620
4621 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Behavior {
4622 #[inline(always)]
4623 fn new_empty() -> Self {
4624 Self::unknown()
4625 }
4626
4627 #[inline]
4628 unsafe fn decode(
4629 &mut self,
4630 decoder: &mut fidl::encoding::Decoder<'_, D>,
4631 offset: usize,
4632 _depth: fidl::encoding::Depth,
4633 ) -> fidl::Result<()> {
4634 decoder.debug_check_bounds::<Self>(offset);
4635 let prim = decoder.read_num::<u32>(offset);
4636
4637 *self = Self::from_primitive_allow_unknown(prim);
4638 Ok(())
4639 }
4640 }
4641 unsafe impl fidl::encoding::TypeMarker for CodecProfile {
4642 type Owned = Self;
4643
4644 #[inline(always)]
4645 fn inline_align(_context: fidl::encoding::Context) -> usize {
4646 std::mem::align_of::<u32>()
4647 }
4648
4649 #[inline(always)]
4650 fn inline_size(_context: fidl::encoding::Context) -> usize {
4651 std::mem::size_of::<u32>()
4652 }
4653
4654 #[inline(always)]
4655 fn encode_is_copy() -> bool {
4656 false
4657 }
4658
4659 #[inline(always)]
4660 fn decode_is_copy() -> bool {
4661 false
4662 }
4663 }
4664
4665 impl fidl::encoding::ValueTypeMarker for CodecProfile {
4666 type Borrowed<'a> = Self;
4667 #[inline(always)]
4668 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4669 *value
4670 }
4671 }
4672
4673 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CodecProfile {
4674 #[inline]
4675 unsafe fn encode(
4676 self,
4677 encoder: &mut fidl::encoding::Encoder<'_, D>,
4678 offset: usize,
4679 _depth: fidl::encoding::Depth,
4680 ) -> fidl::Result<()> {
4681 encoder.debug_check_bounds::<Self>(offset);
4682 encoder.write_num(self.into_primitive(), offset);
4683 Ok(())
4684 }
4685 }
4686
4687 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CodecProfile {
4688 #[inline(always)]
4689 fn new_empty() -> Self {
4690 Self::unknown()
4691 }
4692
4693 #[inline]
4694 unsafe fn decode(
4695 &mut self,
4696 decoder: &mut fidl::encoding::Decoder<'_, D>,
4697 offset: usize,
4698 _depth: fidl::encoding::Depth,
4699 ) -> fidl::Result<()> {
4700 decoder.debug_check_bounds::<Self>(offset);
4701 let prim = decoder.read_num::<u32>(offset);
4702
4703 *self = Self::from_primitive_allow_unknown(prim);
4704 Ok(())
4705 }
4706 }
4707 unsafe impl fidl::encoding::TypeMarker for ColorSpace {
4708 type Owned = Self;
4709
4710 #[inline(always)]
4711 fn inline_align(_context: fidl::encoding::Context) -> usize {
4712 std::mem::align_of::<u32>()
4713 }
4714
4715 #[inline(always)]
4716 fn inline_size(_context: fidl::encoding::Context) -> usize {
4717 std::mem::size_of::<u32>()
4718 }
4719
4720 #[inline(always)]
4721 fn encode_is_copy() -> bool {
4722 true
4723 }
4724
4725 #[inline(always)]
4726 fn decode_is_copy() -> bool {
4727 false
4728 }
4729 }
4730
4731 impl fidl::encoding::ValueTypeMarker for ColorSpace {
4732 type Borrowed<'a> = Self;
4733 #[inline(always)]
4734 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4735 *value
4736 }
4737 }
4738
4739 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ColorSpace {
4740 #[inline]
4741 unsafe fn encode(
4742 self,
4743 encoder: &mut fidl::encoding::Encoder<'_, D>,
4744 offset: usize,
4745 _depth: fidl::encoding::Depth,
4746 ) -> fidl::Result<()> {
4747 encoder.debug_check_bounds::<Self>(offset);
4748 encoder.write_num(self.into_primitive(), offset);
4749 Ok(())
4750 }
4751 }
4752
4753 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorSpace {
4754 #[inline(always)]
4755 fn new_empty() -> Self {
4756 Self::Unknown
4757 }
4758
4759 #[inline]
4760 unsafe fn decode(
4761 &mut self,
4762 decoder: &mut fidl::encoding::Decoder<'_, D>,
4763 offset: usize,
4764 _depth: fidl::encoding::Depth,
4765 ) -> fidl::Result<()> {
4766 decoder.debug_check_bounds::<Self>(offset);
4767 let prim = decoder.read_num::<u32>(offset);
4768
4769 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4770 Ok(())
4771 }
4772 }
4773 unsafe impl fidl::encoding::TypeMarker for Lc3FrameDuration {
4774 type Owned = Self;
4775
4776 #[inline(always)]
4777 fn inline_align(_context: fidl::encoding::Context) -> usize {
4778 std::mem::align_of::<u32>()
4779 }
4780
4781 #[inline(always)]
4782 fn inline_size(_context: fidl::encoding::Context) -> usize {
4783 std::mem::size_of::<u32>()
4784 }
4785
4786 #[inline(always)]
4787 fn encode_is_copy() -> bool {
4788 false
4789 }
4790
4791 #[inline(always)]
4792 fn decode_is_copy() -> bool {
4793 false
4794 }
4795 }
4796
4797 impl fidl::encoding::ValueTypeMarker for Lc3FrameDuration {
4798 type Borrowed<'a> = Self;
4799 #[inline(always)]
4800 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4801 *value
4802 }
4803 }
4804
4805 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4806 for Lc3FrameDuration
4807 {
4808 #[inline]
4809 unsafe fn encode(
4810 self,
4811 encoder: &mut fidl::encoding::Encoder<'_, D>,
4812 offset: usize,
4813 _depth: fidl::encoding::Depth,
4814 ) -> fidl::Result<()> {
4815 encoder.debug_check_bounds::<Self>(offset);
4816 encoder.write_num(self.into_primitive(), offset);
4817 Ok(())
4818 }
4819 }
4820
4821 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3FrameDuration {
4822 #[inline(always)]
4823 fn new_empty() -> Self {
4824 Self::unknown()
4825 }
4826
4827 #[inline]
4828 unsafe fn decode(
4829 &mut self,
4830 decoder: &mut fidl::encoding::Decoder<'_, D>,
4831 offset: usize,
4832 _depth: fidl::encoding::Depth,
4833 ) -> fidl::Result<()> {
4834 decoder.debug_check_bounds::<Self>(offset);
4835 let prim = decoder.read_num::<u32>(offset);
4836
4837 *self = Self::from_primitive_allow_unknown(prim);
4838 Ok(())
4839 }
4840 }
4841 unsafe impl fidl::encoding::TypeMarker for SbcAllocation {
4842 type Owned = Self;
4843
4844 #[inline(always)]
4845 fn inline_align(_context: fidl::encoding::Context) -> usize {
4846 std::mem::align_of::<u32>()
4847 }
4848
4849 #[inline(always)]
4850 fn inline_size(_context: fidl::encoding::Context) -> usize {
4851 std::mem::size_of::<u32>()
4852 }
4853
4854 #[inline(always)]
4855 fn encode_is_copy() -> bool {
4856 true
4857 }
4858
4859 #[inline(always)]
4860 fn decode_is_copy() -> bool {
4861 false
4862 }
4863 }
4864
4865 impl fidl::encoding::ValueTypeMarker for SbcAllocation {
4866 type Borrowed<'a> = Self;
4867 #[inline(always)]
4868 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4869 *value
4870 }
4871 }
4872
4873 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcAllocation {
4874 #[inline]
4875 unsafe fn encode(
4876 self,
4877 encoder: &mut fidl::encoding::Encoder<'_, D>,
4878 offset: usize,
4879 _depth: fidl::encoding::Depth,
4880 ) -> fidl::Result<()> {
4881 encoder.debug_check_bounds::<Self>(offset);
4882 encoder.write_num(self.into_primitive(), offset);
4883 Ok(())
4884 }
4885 }
4886
4887 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcAllocation {
4888 #[inline(always)]
4889 fn new_empty() -> Self {
4890 Self::AllocLoudness
4891 }
4892
4893 #[inline]
4894 unsafe fn decode(
4895 &mut self,
4896 decoder: &mut fidl::encoding::Decoder<'_, D>,
4897 offset: usize,
4898 _depth: fidl::encoding::Depth,
4899 ) -> fidl::Result<()> {
4900 decoder.debug_check_bounds::<Self>(offset);
4901 let prim = decoder.read_num::<u32>(offset);
4902
4903 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4904 Ok(())
4905 }
4906 }
4907 unsafe impl fidl::encoding::TypeMarker for SbcBlockCount {
4908 type Owned = Self;
4909
4910 #[inline(always)]
4911 fn inline_align(_context: fidl::encoding::Context) -> usize {
4912 std::mem::align_of::<u32>()
4913 }
4914
4915 #[inline(always)]
4916 fn inline_size(_context: fidl::encoding::Context) -> usize {
4917 std::mem::size_of::<u32>()
4918 }
4919
4920 #[inline(always)]
4921 fn encode_is_copy() -> bool {
4922 true
4923 }
4924
4925 #[inline(always)]
4926 fn decode_is_copy() -> bool {
4927 false
4928 }
4929 }
4930
4931 impl fidl::encoding::ValueTypeMarker for SbcBlockCount {
4932 type Borrowed<'a> = Self;
4933 #[inline(always)]
4934 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4935 *value
4936 }
4937 }
4938
4939 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcBlockCount {
4940 #[inline]
4941 unsafe fn encode(
4942 self,
4943 encoder: &mut fidl::encoding::Encoder<'_, D>,
4944 offset: usize,
4945 _depth: fidl::encoding::Depth,
4946 ) -> fidl::Result<()> {
4947 encoder.debug_check_bounds::<Self>(offset);
4948 encoder.write_num(self.into_primitive(), offset);
4949 Ok(())
4950 }
4951 }
4952
4953 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcBlockCount {
4954 #[inline(always)]
4955 fn new_empty() -> Self {
4956 Self::BlockCount4
4957 }
4958
4959 #[inline]
4960 unsafe fn decode(
4961 &mut self,
4962 decoder: &mut fidl::encoding::Decoder<'_, D>,
4963 offset: usize,
4964 _depth: fidl::encoding::Depth,
4965 ) -> fidl::Result<()> {
4966 decoder.debug_check_bounds::<Self>(offset);
4967 let prim = decoder.read_num::<u32>(offset);
4968
4969 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4970 Ok(())
4971 }
4972 }
4973 unsafe impl fidl::encoding::TypeMarker for SbcChannelMode {
4974 type Owned = Self;
4975
4976 #[inline(always)]
4977 fn inline_align(_context: fidl::encoding::Context) -> usize {
4978 std::mem::align_of::<u32>()
4979 }
4980
4981 #[inline(always)]
4982 fn inline_size(_context: fidl::encoding::Context) -> usize {
4983 std::mem::size_of::<u32>()
4984 }
4985
4986 #[inline(always)]
4987 fn encode_is_copy() -> bool {
4988 true
4989 }
4990
4991 #[inline(always)]
4992 fn decode_is_copy() -> bool {
4993 false
4994 }
4995 }
4996
4997 impl fidl::encoding::ValueTypeMarker for SbcChannelMode {
4998 type Borrowed<'a> = Self;
4999 #[inline(always)]
5000 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5001 *value
5002 }
5003 }
5004
5005 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcChannelMode {
5006 #[inline]
5007 unsafe fn encode(
5008 self,
5009 encoder: &mut fidl::encoding::Encoder<'_, D>,
5010 offset: usize,
5011 _depth: fidl::encoding::Depth,
5012 ) -> fidl::Result<()> {
5013 encoder.debug_check_bounds::<Self>(offset);
5014 encoder.write_num(self.into_primitive(), offset);
5015 Ok(())
5016 }
5017 }
5018
5019 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcChannelMode {
5020 #[inline(always)]
5021 fn new_empty() -> Self {
5022 Self::Mono
5023 }
5024
5025 #[inline]
5026 unsafe fn decode(
5027 &mut self,
5028 decoder: &mut fidl::encoding::Decoder<'_, D>,
5029 offset: usize,
5030 _depth: fidl::encoding::Depth,
5031 ) -> fidl::Result<()> {
5032 decoder.debug_check_bounds::<Self>(offset);
5033 let prim = decoder.read_num::<u32>(offset);
5034
5035 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5036 Ok(())
5037 }
5038 }
5039 unsafe impl fidl::encoding::TypeMarker for SbcSubBands {
5040 type Owned = Self;
5041
5042 #[inline(always)]
5043 fn inline_align(_context: fidl::encoding::Context) -> usize {
5044 std::mem::align_of::<u32>()
5045 }
5046
5047 #[inline(always)]
5048 fn inline_size(_context: fidl::encoding::Context) -> usize {
5049 std::mem::size_of::<u32>()
5050 }
5051
5052 #[inline(always)]
5053 fn encode_is_copy() -> bool {
5054 true
5055 }
5056
5057 #[inline(always)]
5058 fn decode_is_copy() -> bool {
5059 false
5060 }
5061 }
5062
5063 impl fidl::encoding::ValueTypeMarker for SbcSubBands {
5064 type Borrowed<'a> = Self;
5065 #[inline(always)]
5066 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5067 *value
5068 }
5069 }
5070
5071 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcSubBands {
5072 #[inline]
5073 unsafe fn encode(
5074 self,
5075 encoder: &mut fidl::encoding::Encoder<'_, D>,
5076 offset: usize,
5077 _depth: fidl::encoding::Depth,
5078 ) -> fidl::Result<()> {
5079 encoder.debug_check_bounds::<Self>(offset);
5080 encoder.write_num(self.into_primitive(), offset);
5081 Ok(())
5082 }
5083 }
5084
5085 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcSubBands {
5086 #[inline(always)]
5087 fn new_empty() -> Self {
5088 Self::SubBands4
5089 }
5090
5091 #[inline]
5092 unsafe fn decode(
5093 &mut self,
5094 decoder: &mut fidl::encoding::Decoder<'_, D>,
5095 offset: usize,
5096 _depth: fidl::encoding::Depth,
5097 ) -> fidl::Result<()> {
5098 decoder.debug_check_bounds::<Self>(offset);
5099 let prim = decoder.read_num::<u32>(offset);
5100
5101 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5102 Ok(())
5103 }
5104 }
5105 unsafe impl fidl::encoding::TypeMarker for StreamError {
5106 type Owned = Self;
5107
5108 #[inline(always)]
5109 fn inline_align(_context: fidl::encoding::Context) -> usize {
5110 std::mem::align_of::<u32>()
5111 }
5112
5113 #[inline(always)]
5114 fn inline_size(_context: fidl::encoding::Context) -> usize {
5115 std::mem::size_of::<u32>()
5116 }
5117
5118 #[inline(always)]
5119 fn encode_is_copy() -> bool {
5120 true
5121 }
5122
5123 #[inline(always)]
5124 fn decode_is_copy() -> bool {
5125 false
5126 }
5127 }
5128
5129 impl fidl::encoding::ValueTypeMarker for StreamError {
5130 type Borrowed<'a> = Self;
5131 #[inline(always)]
5132 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5133 *value
5134 }
5135 }
5136
5137 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StreamError {
5138 #[inline]
5139 unsafe fn encode(
5140 self,
5141 encoder: &mut fidl::encoding::Encoder<'_, D>,
5142 offset: usize,
5143 _depth: fidl::encoding::Depth,
5144 ) -> fidl::Result<()> {
5145 encoder.debug_check_bounds::<Self>(offset);
5146 encoder.write_num(self.into_primitive(), offset);
5147 Ok(())
5148 }
5149 }
5150
5151 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamError {
5152 #[inline(always)]
5153 fn new_empty() -> Self {
5154 Self::Unknown
5155 }
5156
5157 #[inline]
5158 unsafe fn decode(
5159 &mut self,
5160 decoder: &mut fidl::encoding::Decoder<'_, D>,
5161 offset: usize,
5162 _depth: fidl::encoding::Depth,
5163 ) -> fidl::Result<()> {
5164 decoder.debug_check_bounds::<Self>(offset);
5165 let prim = decoder.read_num::<u32>(offset);
5166
5167 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5168 Ok(())
5169 }
5170 }
5171 unsafe impl fidl::encoding::TypeMarker for VideoColorSpace {
5172 type Owned = Self;
5173
5174 #[inline(always)]
5175 fn inline_align(_context: fidl::encoding::Context) -> usize {
5176 std::mem::align_of::<u32>()
5177 }
5178
5179 #[inline(always)]
5180 fn inline_size(_context: fidl::encoding::Context) -> usize {
5181 std::mem::size_of::<u32>()
5182 }
5183
5184 #[inline(always)]
5185 fn encode_is_copy() -> bool {
5186 true
5187 }
5188
5189 #[inline(always)]
5190 fn decode_is_copy() -> bool {
5191 false
5192 }
5193 }
5194
5195 impl fidl::encoding::ValueTypeMarker for VideoColorSpace {
5196 type Borrowed<'a> = Self;
5197 #[inline(always)]
5198 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5199 *value
5200 }
5201 }
5202
5203 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
5204 for VideoColorSpace
5205 {
5206 #[inline]
5207 unsafe fn encode(
5208 self,
5209 encoder: &mut fidl::encoding::Encoder<'_, D>,
5210 offset: usize,
5211 _depth: fidl::encoding::Depth,
5212 ) -> fidl::Result<()> {
5213 encoder.debug_check_bounds::<Self>(offset);
5214 encoder.write_num(self.into_primitive(), offset);
5215 Ok(())
5216 }
5217 }
5218
5219 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoColorSpace {
5220 #[inline(always)]
5221 fn new_empty() -> Self {
5222 Self::Invalid
5223 }
5224
5225 #[inline]
5226 unsafe fn decode(
5227 &mut self,
5228 decoder: &mut fidl::encoding::Decoder<'_, D>,
5229 offset: usize,
5230 _depth: fidl::encoding::Depth,
5231 ) -> fidl::Result<()> {
5232 decoder.debug_check_bounds::<Self>(offset);
5233 let prim = decoder.read_num::<u32>(offset);
5234
5235 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5236 Ok(())
5237 }
5238 }
5239
5240 impl fidl::encoding::ValueTypeMarker for AacConstantBitRate {
5241 type Borrowed<'a> = &'a Self;
5242 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5243 value
5244 }
5245 }
5246
5247 unsafe impl fidl::encoding::TypeMarker for AacConstantBitRate {
5248 type Owned = Self;
5249
5250 #[inline(always)]
5251 fn inline_align(_context: fidl::encoding::Context) -> usize {
5252 4
5253 }
5254
5255 #[inline(always)]
5256 fn inline_size(_context: fidl::encoding::Context) -> usize {
5257 4
5258 }
5259 #[inline(always)]
5260 fn encode_is_copy() -> bool {
5261 true
5262 }
5263
5264 #[inline(always)]
5265 fn decode_is_copy() -> bool {
5266 true
5267 }
5268 }
5269
5270 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacConstantBitRate, D>
5271 for &AacConstantBitRate
5272 {
5273 #[inline]
5274 unsafe fn encode(
5275 self,
5276 encoder: &mut fidl::encoding::Encoder<'_, D>,
5277 offset: usize,
5278 _depth: fidl::encoding::Depth,
5279 ) -> fidl::Result<()> {
5280 encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5281 unsafe {
5282 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5284 (buf_ptr as *mut AacConstantBitRate)
5285 .write_unaligned((self as *const AacConstantBitRate).read());
5286 }
5289 Ok(())
5290 }
5291 }
5292 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
5293 fidl::encoding::Encode<AacConstantBitRate, D> for (T0,)
5294 {
5295 #[inline]
5296 unsafe fn encode(
5297 self,
5298 encoder: &mut fidl::encoding::Encoder<'_, D>,
5299 offset: usize,
5300 depth: fidl::encoding::Depth,
5301 ) -> fidl::Result<()> {
5302 encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5303 self.0.encode(encoder, offset + 0, depth)?;
5307 Ok(())
5308 }
5309 }
5310
5311 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacConstantBitRate {
5312 #[inline(always)]
5313 fn new_empty() -> Self {
5314 Self { bit_rate: fidl::new_empty!(u32, D) }
5315 }
5316
5317 #[inline]
5318 unsafe fn decode(
5319 &mut self,
5320 decoder: &mut fidl::encoding::Decoder<'_, D>,
5321 offset: usize,
5322 _depth: fidl::encoding::Depth,
5323 ) -> fidl::Result<()> {
5324 decoder.debug_check_bounds::<Self>(offset);
5325 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5326 unsafe {
5329 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
5330 }
5331 Ok(())
5332 }
5333 }
5334
5335 impl fidl::encoding::ValueTypeMarker for AacEncoderSettings {
5336 type Borrowed<'a> = &'a Self;
5337 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5338 value
5339 }
5340 }
5341
5342 unsafe impl fidl::encoding::TypeMarker for AacEncoderSettings {
5343 type Owned = Self;
5344
5345 #[inline(always)]
5346 fn inline_align(_context: fidl::encoding::Context) -> usize {
5347 8
5348 }
5349
5350 #[inline(always)]
5351 fn inline_size(_context: fidl::encoding::Context) -> usize {
5352 48
5353 }
5354 }
5355
5356 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacEncoderSettings, D>
5357 for &AacEncoderSettings
5358 {
5359 #[inline]
5360 unsafe fn encode(
5361 self,
5362 encoder: &mut fidl::encoding::Encoder<'_, D>,
5363 offset: usize,
5364 _depth: fidl::encoding::Depth,
5365 ) -> fidl::Result<()> {
5366 encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5367 fidl::encoding::Encode::<AacEncoderSettings, D>::encode(
5369 (
5370 <AacTransport as fidl::encoding::ValueTypeMarker>::borrow(&self.transport),
5371 <AacChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
5372 <AacBitRate as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_rate),
5373 <AacAudioObjectType as fidl::encoding::ValueTypeMarker>::borrow(&self.aot),
5374 ),
5375 encoder,
5376 offset,
5377 _depth,
5378 )
5379 }
5380 }
5381 unsafe impl<
5382 D: fidl::encoding::ResourceDialect,
5383 T0: fidl::encoding::Encode<AacTransport, D>,
5384 T1: fidl::encoding::Encode<AacChannelMode, D>,
5385 T2: fidl::encoding::Encode<AacBitRate, D>,
5386 T3: fidl::encoding::Encode<AacAudioObjectType, D>,
5387 > fidl::encoding::Encode<AacEncoderSettings, D> for (T0, T1, T2, T3)
5388 {
5389 #[inline]
5390 unsafe fn encode(
5391 self,
5392 encoder: &mut fidl::encoding::Encoder<'_, D>,
5393 offset: usize,
5394 depth: fidl::encoding::Depth,
5395 ) -> fidl::Result<()> {
5396 encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5397 unsafe {
5400 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
5401 (ptr as *mut u64).write_unaligned(0);
5402 }
5403 unsafe {
5404 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
5405 (ptr as *mut u64).write_unaligned(0);
5406 }
5407 self.0.encode(encoder, offset + 0, depth)?;
5409 self.1.encode(encoder, offset + 16, depth)?;
5410 self.2.encode(encoder, offset + 24, depth)?;
5411 self.3.encode(encoder, offset + 40, depth)?;
5412 Ok(())
5413 }
5414 }
5415
5416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacEncoderSettings {
5417 #[inline(always)]
5418 fn new_empty() -> Self {
5419 Self {
5420 transport: fidl::new_empty!(AacTransport, D),
5421 channel_mode: fidl::new_empty!(AacChannelMode, D),
5422 bit_rate: fidl::new_empty!(AacBitRate, D),
5423 aot: fidl::new_empty!(AacAudioObjectType, D),
5424 }
5425 }
5426
5427 #[inline]
5428 unsafe fn decode(
5429 &mut self,
5430 decoder: &mut fidl::encoding::Decoder<'_, D>,
5431 offset: usize,
5432 _depth: fidl::encoding::Depth,
5433 ) -> fidl::Result<()> {
5434 decoder.debug_check_bounds::<Self>(offset);
5435 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
5437 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5438 let mask = 0xffffffff00000000u64;
5439 let maskedval = padval & mask;
5440 if maskedval != 0 {
5441 return Err(fidl::Error::NonZeroPadding {
5442 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
5443 });
5444 }
5445 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
5446 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5447 let mask = 0xffffffff00000000u64;
5448 let maskedval = padval & mask;
5449 if maskedval != 0 {
5450 return Err(fidl::Error::NonZeroPadding {
5451 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
5452 });
5453 }
5454 fidl::decode!(AacTransport, D, &mut self.transport, decoder, offset + 0, _depth)?;
5455 fidl::decode!(AacChannelMode, D, &mut self.channel_mode, decoder, offset + 16, _depth)?;
5456 fidl::decode!(AacBitRate, D, &mut self.bit_rate, decoder, offset + 24, _depth)?;
5457 fidl::decode!(AacAudioObjectType, D, &mut self.aot, decoder, offset + 40, _depth)?;
5458 Ok(())
5459 }
5460 }
5461
5462 impl fidl::encoding::ValueTypeMarker for AacTransportAdts {
5463 type Borrowed<'a> = &'a Self;
5464 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5465 value
5466 }
5467 }
5468
5469 unsafe impl fidl::encoding::TypeMarker for AacTransportAdts {
5470 type Owned = Self;
5471
5472 #[inline(always)]
5473 fn inline_align(_context: fidl::encoding::Context) -> usize {
5474 1
5475 }
5476
5477 #[inline(always)]
5478 fn inline_size(_context: fidl::encoding::Context) -> usize {
5479 1
5480 }
5481 }
5482
5483 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportAdts, D>
5484 for &AacTransportAdts
5485 {
5486 #[inline]
5487 unsafe fn encode(
5488 self,
5489 encoder: &mut fidl::encoding::Encoder<'_, D>,
5490 offset: usize,
5491 _depth: fidl::encoding::Depth,
5492 ) -> fidl::Result<()> {
5493 encoder.debug_check_bounds::<AacTransportAdts>(offset);
5494 encoder.write_num(0u8, offset);
5495 Ok(())
5496 }
5497 }
5498
5499 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportAdts {
5500 #[inline(always)]
5501 fn new_empty() -> Self {
5502 Self
5503 }
5504
5505 #[inline]
5506 unsafe fn decode(
5507 &mut self,
5508 decoder: &mut fidl::encoding::Decoder<'_, D>,
5509 offset: usize,
5510 _depth: fidl::encoding::Depth,
5511 ) -> fidl::Result<()> {
5512 decoder.debug_check_bounds::<Self>(offset);
5513 match decoder.read_num::<u8>(offset) {
5514 0 => Ok(()),
5515 _ => Err(fidl::Error::Invalid),
5516 }
5517 }
5518 }
5519
5520 impl fidl::encoding::ValueTypeMarker for AacTransportLatm {
5521 type Borrowed<'a> = &'a Self;
5522 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5523 value
5524 }
5525 }
5526
5527 unsafe impl fidl::encoding::TypeMarker for AacTransportLatm {
5528 type Owned = Self;
5529
5530 #[inline(always)]
5531 fn inline_align(_context: fidl::encoding::Context) -> usize {
5532 1
5533 }
5534
5535 #[inline(always)]
5536 fn inline_size(_context: fidl::encoding::Context) -> usize {
5537 1
5538 }
5539 }
5540
5541 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportLatm, D>
5542 for &AacTransportLatm
5543 {
5544 #[inline]
5545 unsafe fn encode(
5546 self,
5547 encoder: &mut fidl::encoding::Encoder<'_, D>,
5548 offset: usize,
5549 _depth: fidl::encoding::Depth,
5550 ) -> fidl::Result<()> {
5551 encoder.debug_check_bounds::<AacTransportLatm>(offset);
5552 fidl::encoding::Encode::<AacTransportLatm, D>::encode(
5554 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.mux_config_present),),
5555 encoder,
5556 offset,
5557 _depth,
5558 )
5559 }
5560 }
5561 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
5562 fidl::encoding::Encode<AacTransportLatm, D> for (T0,)
5563 {
5564 #[inline]
5565 unsafe fn encode(
5566 self,
5567 encoder: &mut fidl::encoding::Encoder<'_, D>,
5568 offset: usize,
5569 depth: fidl::encoding::Depth,
5570 ) -> fidl::Result<()> {
5571 encoder.debug_check_bounds::<AacTransportLatm>(offset);
5572 self.0.encode(encoder, offset + 0, depth)?;
5576 Ok(())
5577 }
5578 }
5579
5580 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportLatm {
5581 #[inline(always)]
5582 fn new_empty() -> Self {
5583 Self { mux_config_present: fidl::new_empty!(bool, D) }
5584 }
5585
5586 #[inline]
5587 unsafe fn decode(
5588 &mut self,
5589 decoder: &mut fidl::encoding::Decoder<'_, D>,
5590 offset: usize,
5591 _depth: fidl::encoding::Depth,
5592 ) -> fidl::Result<()> {
5593 decoder.debug_check_bounds::<Self>(offset);
5594 fidl::decode!(bool, D, &mut self.mux_config_present, decoder, offset + 0, _depth)?;
5596 Ok(())
5597 }
5598 }
5599
5600 impl fidl::encoding::ValueTypeMarker for AacTransportRaw {
5601 type Borrowed<'a> = &'a Self;
5602 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5603 value
5604 }
5605 }
5606
5607 unsafe impl fidl::encoding::TypeMarker for AacTransportRaw {
5608 type Owned = Self;
5609
5610 #[inline(always)]
5611 fn inline_align(_context: fidl::encoding::Context) -> usize {
5612 1
5613 }
5614
5615 #[inline(always)]
5616 fn inline_size(_context: fidl::encoding::Context) -> usize {
5617 1
5618 }
5619 }
5620
5621 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportRaw, D>
5622 for &AacTransportRaw
5623 {
5624 #[inline]
5625 unsafe fn encode(
5626 self,
5627 encoder: &mut fidl::encoding::Encoder<'_, D>,
5628 offset: usize,
5629 _depth: fidl::encoding::Depth,
5630 ) -> fidl::Result<()> {
5631 encoder.debug_check_bounds::<AacTransportRaw>(offset);
5632 encoder.write_num(0u8, offset);
5633 Ok(())
5634 }
5635 }
5636
5637 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportRaw {
5638 #[inline(always)]
5639 fn new_empty() -> Self {
5640 Self
5641 }
5642
5643 #[inline]
5644 unsafe fn decode(
5645 &mut self,
5646 decoder: &mut fidl::encoding::Decoder<'_, D>,
5647 offset: usize,
5648 _depth: fidl::encoding::Depth,
5649 ) -> fidl::Result<()> {
5650 decoder.debug_check_bounds::<Self>(offset);
5651 match decoder.read_num::<u8>(offset) {
5652 0 => Ok(()),
5653 _ => Err(fidl::Error::Invalid),
5654 }
5655 }
5656 }
5657
5658 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivityResponse {
5659 type Borrowed<'a> = &'a Self;
5660 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5661 value
5662 }
5663 }
5664
5665 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivityResponse {
5666 type Owned = Self;
5667
5668 #[inline(always)]
5669 fn inline_align(_context: fidl::encoding::Context) -> usize {
5670 8
5671 }
5672
5673 #[inline(always)]
5674 fn inline_size(_context: fidl::encoding::Context) -> usize {
5675 16
5676 }
5677 }
5678
5679 unsafe impl<D: fidl::encoding::ResourceDialect>
5680 fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D>
5681 for &ActivityReporterWatchCaptureActivityResponse
5682 {
5683 #[inline]
5684 unsafe fn encode(
5685 self,
5686 encoder: &mut fidl::encoding::Encoder<'_, D>,
5687 offset: usize,
5688 _depth: fidl::encoding::Depth,
5689 ) -> fidl::Result<()> {
5690 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5691 fidl::encoding::Encode::<ActivityReporterWatchCaptureActivityResponse, D>::encode(
5693 (
5694 <fidl::encoding::Vector<AudioCaptureUsage, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5695 ),
5696 encoder, offset, _depth
5697 )
5698 }
5699 }
5700 unsafe impl<
5701 D: fidl::encoding::ResourceDialect,
5702 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage, 4>, D>,
5703 > fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D> for (T0,)
5704 {
5705 #[inline]
5706 unsafe fn encode(
5707 self,
5708 encoder: &mut fidl::encoding::Encoder<'_, D>,
5709 offset: usize,
5710 depth: fidl::encoding::Depth,
5711 ) -> fidl::Result<()> {
5712 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5713 self.0.encode(encoder, offset + 0, depth)?;
5717 Ok(())
5718 }
5719 }
5720
5721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5722 for ActivityReporterWatchCaptureActivityResponse
5723 {
5724 #[inline(always)]
5725 fn new_empty() -> Self {
5726 Self {
5727 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D),
5728 }
5729 }
5730
5731 #[inline]
5732 unsafe fn decode(
5733 &mut self,
5734 decoder: &mut fidl::encoding::Decoder<'_, D>,
5735 offset: usize,
5736 _depth: fidl::encoding::Depth,
5737 ) -> fidl::Result<()> {
5738 decoder.debug_check_bounds::<Self>(offset);
5739 fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5741 Ok(())
5742 }
5743 }
5744
5745 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivityResponse {
5746 type Borrowed<'a> = &'a Self;
5747 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5748 value
5749 }
5750 }
5751
5752 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivityResponse {
5753 type Owned = Self;
5754
5755 #[inline(always)]
5756 fn inline_align(_context: fidl::encoding::Context) -> usize {
5757 8
5758 }
5759
5760 #[inline(always)]
5761 fn inline_size(_context: fidl::encoding::Context) -> usize {
5762 16
5763 }
5764 }
5765
5766 unsafe impl<D: fidl::encoding::ResourceDialect>
5767 fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D>
5768 for &ActivityReporterWatchRenderActivityResponse
5769 {
5770 #[inline]
5771 unsafe fn encode(
5772 self,
5773 encoder: &mut fidl::encoding::Encoder<'_, D>,
5774 offset: usize,
5775 _depth: fidl::encoding::Depth,
5776 ) -> fidl::Result<()> {
5777 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5778 fidl::encoding::Encode::<ActivityReporterWatchRenderActivityResponse, D>::encode(
5780 (
5781 <fidl::encoding::Vector<AudioRenderUsage, 5> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5782 ),
5783 encoder, offset, _depth
5784 )
5785 }
5786 }
5787 unsafe impl<
5788 D: fidl::encoding::ResourceDialect,
5789 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage, 5>, D>,
5790 > fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D> for (T0,)
5791 {
5792 #[inline]
5793 unsafe fn encode(
5794 self,
5795 encoder: &mut fidl::encoding::Encoder<'_, D>,
5796 offset: usize,
5797 depth: fidl::encoding::Depth,
5798 ) -> fidl::Result<()> {
5799 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5800 self.0.encode(encoder, offset + 0, depth)?;
5804 Ok(())
5805 }
5806 }
5807
5808 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5809 for ActivityReporterWatchRenderActivityResponse
5810 {
5811 #[inline(always)]
5812 fn new_empty() -> Self {
5813 Self { active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage, 5>, D) }
5814 }
5815
5816 #[inline]
5817 unsafe fn decode(
5818 &mut self,
5819 decoder: &mut fidl::encoding::Decoder<'_, D>,
5820 offset: usize,
5821 _depth: fidl::encoding::Depth,
5822 ) -> fidl::Result<()> {
5823 decoder.debug_check_bounds::<Self>(offset);
5824 fidl::decode!(fidl::encoding::Vector<AudioRenderUsage, 5>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5826 Ok(())
5827 }
5828 }
5829
5830 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivity2Response {
5831 type Borrowed<'a> = &'a Self;
5832 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5833 value
5834 }
5835 }
5836
5837 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivity2Response {
5838 type Owned = Self;
5839
5840 #[inline(always)]
5841 fn inline_align(_context: fidl::encoding::Context) -> usize {
5842 8
5843 }
5844
5845 #[inline(always)]
5846 fn inline_size(_context: fidl::encoding::Context) -> usize {
5847 16
5848 }
5849 }
5850
5851 unsafe impl<D: fidl::encoding::ResourceDialect>
5852 fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D>
5853 for &ActivityReporterWatchCaptureActivity2Response
5854 {
5855 #[inline]
5856 unsafe fn encode(
5857 self,
5858 encoder: &mut fidl::encoding::Encoder<'_, D>,
5859 offset: usize,
5860 _depth: fidl::encoding::Depth,
5861 ) -> fidl::Result<()> {
5862 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5863 fidl::encoding::Encode::<ActivityReporterWatchCaptureActivity2Response, D>::encode(
5865 (
5866 <fidl::encoding::Vector<AudioCaptureUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5867 ),
5868 encoder, offset, _depth
5869 )
5870 }
5871 }
5872 unsafe impl<
5873 D: fidl::encoding::ResourceDialect,
5874 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage2, 8>, D>,
5875 > fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D> for (T0,)
5876 {
5877 #[inline]
5878 unsafe fn encode(
5879 self,
5880 encoder: &mut fidl::encoding::Encoder<'_, D>,
5881 offset: usize,
5882 depth: fidl::encoding::Depth,
5883 ) -> fidl::Result<()> {
5884 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5885 self.0.encode(encoder, offset + 0, depth)?;
5889 Ok(())
5890 }
5891 }
5892
5893 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5894 for ActivityReporterWatchCaptureActivity2Response
5895 {
5896 #[inline(always)]
5897 fn new_empty() -> Self {
5898 Self {
5899 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D),
5900 }
5901 }
5902
5903 #[inline]
5904 unsafe fn decode(
5905 &mut self,
5906 decoder: &mut fidl::encoding::Decoder<'_, D>,
5907 offset: usize,
5908 _depth: fidl::encoding::Depth,
5909 ) -> fidl::Result<()> {
5910 decoder.debug_check_bounds::<Self>(offset);
5911 fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5913 Ok(())
5914 }
5915 }
5916
5917 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivity2Response {
5918 type Borrowed<'a> = &'a Self;
5919 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5920 value
5921 }
5922 }
5923
5924 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivity2Response {
5925 type Owned = Self;
5926
5927 #[inline(always)]
5928 fn inline_align(_context: fidl::encoding::Context) -> usize {
5929 8
5930 }
5931
5932 #[inline(always)]
5933 fn inline_size(_context: fidl::encoding::Context) -> usize {
5934 16
5935 }
5936 }
5937
5938 unsafe impl<D: fidl::encoding::ResourceDialect>
5939 fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D>
5940 for &ActivityReporterWatchRenderActivity2Response
5941 {
5942 #[inline]
5943 unsafe fn encode(
5944 self,
5945 encoder: &mut fidl::encoding::Encoder<'_, D>,
5946 offset: usize,
5947 _depth: fidl::encoding::Depth,
5948 ) -> fidl::Result<()> {
5949 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5950 fidl::encoding::Encode::<ActivityReporterWatchRenderActivity2Response, D>::encode(
5952 (
5953 <fidl::encoding::Vector<AudioRenderUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5954 ),
5955 encoder, offset, _depth
5956 )
5957 }
5958 }
5959 unsafe impl<
5960 D: fidl::encoding::ResourceDialect,
5961 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage2, 8>, D>,
5962 > fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D> for (T0,)
5963 {
5964 #[inline]
5965 unsafe fn encode(
5966 self,
5967 encoder: &mut fidl::encoding::Encoder<'_, D>,
5968 offset: usize,
5969 depth: fidl::encoding::Depth,
5970 ) -> fidl::Result<()> {
5971 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5972 self.0.encode(encoder, offset + 0, depth)?;
5976 Ok(())
5977 }
5978 }
5979
5980 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5981 for ActivityReporterWatchRenderActivity2Response
5982 {
5983 #[inline(always)]
5984 fn new_empty() -> Self {
5985 Self {
5986 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D),
5987 }
5988 }
5989
5990 #[inline]
5991 unsafe fn decode(
5992 &mut self,
5993 decoder: &mut fidl::encoding::Decoder<'_, D>,
5994 offset: usize,
5995 _depth: fidl::encoding::Depth,
5996 ) -> fidl::Result<()> {
5997 decoder.debug_check_bounds::<Self>(offset);
5998 fidl::decode!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
6000 Ok(())
6001 }
6002 }
6003
6004 impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtRequest {
6005 type Borrowed<'a> = &'a Self;
6006 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6007 value
6008 }
6009 }
6010
6011 unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtRequest {
6012 type Owned = Self;
6013
6014 #[inline(always)]
6015 fn inline_align(_context: fidl::encoding::Context) -> usize {
6016 4
6017 }
6018
6019 #[inline(always)]
6020 fn inline_size(_context: fidl::encoding::Context) -> usize {
6021 12
6022 }
6023 #[inline(always)]
6024 fn encode_is_copy() -> bool {
6025 true
6026 }
6027
6028 #[inline(always)]
6029 fn decode_is_copy() -> bool {
6030 true
6031 }
6032 }
6033
6034 unsafe impl<D: fidl::encoding::ResourceDialect>
6035 fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D>
6036 for &AudioCapturerCaptureAtRequest
6037 {
6038 #[inline]
6039 unsafe fn encode(
6040 self,
6041 encoder: &mut fidl::encoding::Encoder<'_, D>,
6042 offset: usize,
6043 _depth: fidl::encoding::Depth,
6044 ) -> fidl::Result<()> {
6045 encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
6046 unsafe {
6047 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6049 (buf_ptr as *mut AudioCapturerCaptureAtRequest)
6050 .write_unaligned((self as *const AudioCapturerCaptureAtRequest).read());
6051 }
6054 Ok(())
6055 }
6056 }
6057 unsafe impl<
6058 D: fidl::encoding::ResourceDialect,
6059 T0: fidl::encoding::Encode<u32, D>,
6060 T1: fidl::encoding::Encode<u32, D>,
6061 T2: fidl::encoding::Encode<u32, D>,
6062 > fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D> for (T0, T1, T2)
6063 {
6064 #[inline]
6065 unsafe fn encode(
6066 self,
6067 encoder: &mut fidl::encoding::Encoder<'_, D>,
6068 offset: usize,
6069 depth: fidl::encoding::Depth,
6070 ) -> fidl::Result<()> {
6071 encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
6072 self.0.encode(encoder, offset + 0, depth)?;
6076 self.1.encode(encoder, offset + 4, depth)?;
6077 self.2.encode(encoder, offset + 8, depth)?;
6078 Ok(())
6079 }
6080 }
6081
6082 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6083 for AudioCapturerCaptureAtRequest
6084 {
6085 #[inline(always)]
6086 fn new_empty() -> Self {
6087 Self {
6088 payload_buffer_id: fidl::new_empty!(u32, D),
6089 payload_offset: fidl::new_empty!(u32, D),
6090 frames: fidl::new_empty!(u32, D),
6091 }
6092 }
6093
6094 #[inline]
6095 unsafe fn decode(
6096 &mut self,
6097 decoder: &mut fidl::encoding::Decoder<'_, D>,
6098 offset: usize,
6099 _depth: fidl::encoding::Depth,
6100 ) -> fidl::Result<()> {
6101 decoder.debug_check_bounds::<Self>(offset);
6102 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6103 unsafe {
6106 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
6107 }
6108 Ok(())
6109 }
6110 }
6111
6112 impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtResponse {
6113 type Borrowed<'a> = &'a Self;
6114 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6115 value
6116 }
6117 }
6118
6119 unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtResponse {
6120 type Owned = Self;
6121
6122 #[inline(always)]
6123 fn inline_align(_context: fidl::encoding::Context) -> usize {
6124 8
6125 }
6126
6127 #[inline(always)]
6128 fn inline_size(_context: fidl::encoding::Context) -> usize {
6129 56
6130 }
6131 }
6132
6133 unsafe impl<D: fidl::encoding::ResourceDialect>
6134 fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D>
6135 for &AudioCapturerCaptureAtResponse
6136 {
6137 #[inline]
6138 unsafe fn encode(
6139 self,
6140 encoder: &mut fidl::encoding::Encoder<'_, D>,
6141 offset: usize,
6142 _depth: fidl::encoding::Depth,
6143 ) -> fidl::Result<()> {
6144 encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
6145 unsafe {
6146 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6148 (buf_ptr as *mut AudioCapturerCaptureAtResponse)
6149 .write_unaligned((self as *const AudioCapturerCaptureAtResponse).read());
6150 let padding_ptr = buf_ptr.offset(8) as *mut u64;
6153 let padding_mask = 0xffffffff00000000u64;
6154 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
6155 let padding_ptr = buf_ptr.offset(32) as *mut u64;
6156 let padding_mask = 0xffffffff00000000u64;
6157 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
6158 }
6159 Ok(())
6160 }
6161 }
6162 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
6163 fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D> for (T0,)
6164 {
6165 #[inline]
6166 unsafe fn encode(
6167 self,
6168 encoder: &mut fidl::encoding::Encoder<'_, D>,
6169 offset: usize,
6170 depth: fidl::encoding::Depth,
6171 ) -> fidl::Result<()> {
6172 encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
6173 self.0.encode(encoder, offset + 0, depth)?;
6177 Ok(())
6178 }
6179 }
6180
6181 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6182 for AudioCapturerCaptureAtResponse
6183 {
6184 #[inline(always)]
6185 fn new_empty() -> Self {
6186 Self { captured_packet: fidl::new_empty!(StreamPacket, D) }
6187 }
6188
6189 #[inline]
6190 unsafe fn decode(
6191 &mut self,
6192 decoder: &mut fidl::encoding::Decoder<'_, D>,
6193 offset: usize,
6194 _depth: fidl::encoding::Depth,
6195 ) -> fidl::Result<()> {
6196 decoder.debug_check_bounds::<Self>(offset);
6197 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6198 let ptr = unsafe { buf_ptr.offset(8) };
6200 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6201 let mask = 0xffffffff00000000u64;
6202 let maskedval = padval & mask;
6203 if maskedval != 0 {
6204 return Err(fidl::Error::NonZeroPadding {
6205 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
6206 });
6207 }
6208 let ptr = unsafe { buf_ptr.offset(32) };
6209 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6210 let mask = 0xffffffff00000000u64;
6211 let maskedval = padval & mask;
6212 if maskedval != 0 {
6213 return Err(fidl::Error::NonZeroPadding {
6214 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
6215 });
6216 }
6217 unsafe {
6219 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
6220 }
6221 Ok(())
6222 }
6223 }
6224
6225 impl fidl::encoding::ValueTypeMarker for AudioCapturerGetStreamTypeResponse {
6226 type Borrowed<'a> = &'a Self;
6227 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6228 value
6229 }
6230 }
6231
6232 unsafe impl fidl::encoding::TypeMarker for AudioCapturerGetStreamTypeResponse {
6233 type Owned = Self;
6234
6235 #[inline(always)]
6236 fn inline_align(_context: fidl::encoding::Context) -> usize {
6237 8
6238 }
6239
6240 #[inline(always)]
6241 fn inline_size(_context: fidl::encoding::Context) -> usize {
6242 48
6243 }
6244 }
6245
6246 unsafe impl<D: fidl::encoding::ResourceDialect>
6247 fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D>
6248 for &AudioCapturerGetStreamTypeResponse
6249 {
6250 #[inline]
6251 unsafe fn encode(
6252 self,
6253 encoder: &mut fidl::encoding::Encoder<'_, D>,
6254 offset: usize,
6255 _depth: fidl::encoding::Depth,
6256 ) -> fidl::Result<()> {
6257 encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6258 fidl::encoding::Encode::<AudioCapturerGetStreamTypeResponse, D>::encode(
6260 (<StreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6261 encoder,
6262 offset,
6263 _depth,
6264 )
6265 }
6266 }
6267 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamType, D>>
6268 fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D> for (T0,)
6269 {
6270 #[inline]
6271 unsafe fn encode(
6272 self,
6273 encoder: &mut fidl::encoding::Encoder<'_, D>,
6274 offset: usize,
6275 depth: fidl::encoding::Depth,
6276 ) -> fidl::Result<()> {
6277 encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6278 self.0.encode(encoder, offset + 0, depth)?;
6282 Ok(())
6283 }
6284 }
6285
6286 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6287 for AudioCapturerGetStreamTypeResponse
6288 {
6289 #[inline(always)]
6290 fn new_empty() -> Self {
6291 Self { stream_type: fidl::new_empty!(StreamType, D) }
6292 }
6293
6294 #[inline]
6295 unsafe fn decode(
6296 &mut self,
6297 decoder: &mut fidl::encoding::Decoder<'_, D>,
6298 offset: usize,
6299 _depth: fidl::encoding::Depth,
6300 ) -> fidl::Result<()> {
6301 decoder.debug_check_bounds::<Self>(offset);
6302 fidl::decode!(StreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6304 Ok(())
6305 }
6306 }
6307
6308 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6309 type Borrowed<'a> = &'a Self;
6310 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6311 value
6312 }
6313 }
6314
6315 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6316 type Owned = Self;
6317
6318 #[inline(always)]
6319 fn inline_align(_context: fidl::encoding::Context) -> usize {
6320 4
6321 }
6322
6323 #[inline(always)]
6324 fn inline_size(_context: fidl::encoding::Context) -> usize {
6325 12
6326 }
6327 }
6328
6329 unsafe impl<D: fidl::encoding::ResourceDialect>
6330 fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D>
6331 for &AudioCapturerSetPcmStreamTypeRequest
6332 {
6333 #[inline]
6334 unsafe fn encode(
6335 self,
6336 encoder: &mut fidl::encoding::Encoder<'_, D>,
6337 offset: usize,
6338 _depth: fidl::encoding::Depth,
6339 ) -> fidl::Result<()> {
6340 encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6341 fidl::encoding::Encode::<AudioCapturerSetPcmStreamTypeRequest, D>::encode(
6343 (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6344 encoder,
6345 offset,
6346 _depth,
6347 )
6348 }
6349 }
6350 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
6351 fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D> for (T0,)
6352 {
6353 #[inline]
6354 unsafe fn encode(
6355 self,
6356 encoder: &mut fidl::encoding::Encoder<'_, D>,
6357 offset: usize,
6358 depth: fidl::encoding::Depth,
6359 ) -> fidl::Result<()> {
6360 encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6361 self.0.encode(encoder, offset + 0, depth)?;
6365 Ok(())
6366 }
6367 }
6368
6369 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6370 for AudioCapturerSetPcmStreamTypeRequest
6371 {
6372 #[inline(always)]
6373 fn new_empty() -> Self {
6374 Self { stream_type: fidl::new_empty!(AudioStreamType, D) }
6375 }
6376
6377 #[inline]
6378 unsafe fn decode(
6379 &mut self,
6380 decoder: &mut fidl::encoding::Decoder<'_, D>,
6381 offset: usize,
6382 _depth: fidl::encoding::Depth,
6383 ) -> fidl::Result<()> {
6384 decoder.debug_check_bounds::<Self>(offset);
6385 fidl::decode!(AudioStreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6387 Ok(())
6388 }
6389 }
6390
6391 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsage2Request {
6392 type Borrowed<'a> = &'a Self;
6393 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6394 value
6395 }
6396 }
6397
6398 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsage2Request {
6399 type Owned = Self;
6400
6401 #[inline(always)]
6402 fn inline_align(_context: fidl::encoding::Context) -> usize {
6403 4
6404 }
6405
6406 #[inline(always)]
6407 fn inline_size(_context: fidl::encoding::Context) -> usize {
6408 4
6409 }
6410 }
6411
6412 unsafe impl<D: fidl::encoding::ResourceDialect>
6413 fidl::encoding::Encode<AudioCapturerSetUsage2Request, D>
6414 for &AudioCapturerSetUsage2Request
6415 {
6416 #[inline]
6417 unsafe fn encode(
6418 self,
6419 encoder: &mut fidl::encoding::Encoder<'_, D>,
6420 offset: usize,
6421 _depth: fidl::encoding::Depth,
6422 ) -> fidl::Result<()> {
6423 encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6424 fidl::encoding::Encode::<AudioCapturerSetUsage2Request, D>::encode(
6426 (<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6427 encoder,
6428 offset,
6429 _depth,
6430 )
6431 }
6432 }
6433 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage2, D>>
6434 fidl::encoding::Encode<AudioCapturerSetUsage2Request, D> for (T0,)
6435 {
6436 #[inline]
6437 unsafe fn encode(
6438 self,
6439 encoder: &mut fidl::encoding::Encoder<'_, D>,
6440 offset: usize,
6441 depth: fidl::encoding::Depth,
6442 ) -> fidl::Result<()> {
6443 encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6444 self.0.encode(encoder, offset + 0, depth)?;
6448 Ok(())
6449 }
6450 }
6451
6452 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6453 for AudioCapturerSetUsage2Request
6454 {
6455 #[inline(always)]
6456 fn new_empty() -> Self {
6457 Self { usage: fidl::new_empty!(AudioCaptureUsage2, D) }
6458 }
6459
6460 #[inline]
6461 unsafe fn decode(
6462 &mut self,
6463 decoder: &mut fidl::encoding::Decoder<'_, D>,
6464 offset: usize,
6465 _depth: fidl::encoding::Depth,
6466 ) -> fidl::Result<()> {
6467 decoder.debug_check_bounds::<Self>(offset);
6468 fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
6470 Ok(())
6471 }
6472 }
6473
6474 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsageRequest {
6475 type Borrowed<'a> = &'a Self;
6476 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6477 value
6478 }
6479 }
6480
6481 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsageRequest {
6482 type Owned = Self;
6483
6484 #[inline(always)]
6485 fn inline_align(_context: fidl::encoding::Context) -> usize {
6486 4
6487 }
6488
6489 #[inline(always)]
6490 fn inline_size(_context: fidl::encoding::Context) -> usize {
6491 4
6492 }
6493 }
6494
6495 unsafe impl<D: fidl::encoding::ResourceDialect>
6496 fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for &AudioCapturerSetUsageRequest
6497 {
6498 #[inline]
6499 unsafe fn encode(
6500 self,
6501 encoder: &mut fidl::encoding::Encoder<'_, D>,
6502 offset: usize,
6503 _depth: fidl::encoding::Depth,
6504 ) -> fidl::Result<()> {
6505 encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6506 fidl::encoding::Encode::<AudioCapturerSetUsageRequest, D>::encode(
6508 (<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6509 encoder,
6510 offset,
6511 _depth,
6512 )
6513 }
6514 }
6515 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage, D>>
6516 fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for (T0,)
6517 {
6518 #[inline]
6519 unsafe fn encode(
6520 self,
6521 encoder: &mut fidl::encoding::Encoder<'_, D>,
6522 offset: usize,
6523 depth: fidl::encoding::Depth,
6524 ) -> fidl::Result<()> {
6525 encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6526 self.0.encode(encoder, offset + 0, depth)?;
6530 Ok(())
6531 }
6532 }
6533
6534 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6535 for AudioCapturerSetUsageRequest
6536 {
6537 #[inline(always)]
6538 fn new_empty() -> Self {
6539 Self { usage: fidl::new_empty!(AudioCaptureUsage, D) }
6540 }
6541
6542 #[inline]
6543 unsafe fn decode(
6544 &mut self,
6545 decoder: &mut fidl::encoding::Decoder<'_, D>,
6546 offset: usize,
6547 _depth: fidl::encoding::Depth,
6548 ) -> fidl::Result<()> {
6549 decoder.debug_check_bounds::<Self>(offset);
6550 fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
6552 Ok(())
6553 }
6554 }
6555
6556 impl fidl::encoding::ValueTypeMarker for AudioCapturerStartAsyncCaptureRequest {
6557 type Borrowed<'a> = &'a Self;
6558 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6559 value
6560 }
6561 }
6562
6563 unsafe impl fidl::encoding::TypeMarker for AudioCapturerStartAsyncCaptureRequest {
6564 type Owned = Self;
6565
6566 #[inline(always)]
6567 fn inline_align(_context: fidl::encoding::Context) -> usize {
6568 4
6569 }
6570
6571 #[inline(always)]
6572 fn inline_size(_context: fidl::encoding::Context) -> usize {
6573 4
6574 }
6575 #[inline(always)]
6576 fn encode_is_copy() -> bool {
6577 true
6578 }
6579
6580 #[inline(always)]
6581 fn decode_is_copy() -> bool {
6582 true
6583 }
6584 }
6585
6586 unsafe impl<D: fidl::encoding::ResourceDialect>
6587 fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D>
6588 for &AudioCapturerStartAsyncCaptureRequest
6589 {
6590 #[inline]
6591 unsafe fn encode(
6592 self,
6593 encoder: &mut fidl::encoding::Encoder<'_, D>,
6594 offset: usize,
6595 _depth: fidl::encoding::Depth,
6596 ) -> fidl::Result<()> {
6597 encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6598 unsafe {
6599 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6601 (buf_ptr as *mut AudioCapturerStartAsyncCaptureRequest)
6602 .write_unaligned((self as *const AudioCapturerStartAsyncCaptureRequest).read());
6603 }
6606 Ok(())
6607 }
6608 }
6609 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
6610 fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D> for (T0,)
6611 {
6612 #[inline]
6613 unsafe fn encode(
6614 self,
6615 encoder: &mut fidl::encoding::Encoder<'_, D>,
6616 offset: usize,
6617 depth: fidl::encoding::Depth,
6618 ) -> fidl::Result<()> {
6619 encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6620 self.0.encode(encoder, offset + 0, depth)?;
6624 Ok(())
6625 }
6626 }
6627
6628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6629 for AudioCapturerStartAsyncCaptureRequest
6630 {
6631 #[inline(always)]
6632 fn new_empty() -> Self {
6633 Self { frames_per_packet: fidl::new_empty!(u32, D) }
6634 }
6635
6636 #[inline]
6637 unsafe fn decode(
6638 &mut self,
6639 decoder: &mut fidl::encoding::Decoder<'_, D>,
6640 offset: usize,
6641 _depth: fidl::encoding::Depth,
6642 ) -> fidl::Result<()> {
6643 decoder.debug_check_bounds::<Self>(offset);
6644 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6645 unsafe {
6648 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
6649 }
6650 Ok(())
6651 }
6652 }
6653
6654 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatAac {
6655 type Borrowed<'a> = &'a Self;
6656 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6657 value
6658 }
6659 }
6660
6661 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatAac {
6662 type Owned = Self;
6663
6664 #[inline(always)]
6665 fn inline_align(_context: fidl::encoding::Context) -> usize {
6666 1
6667 }
6668
6669 #[inline(always)]
6670 fn inline_size(_context: fidl::encoding::Context) -> usize {
6671 1
6672 }
6673 }
6674
6675 unsafe impl<D: fidl::encoding::ResourceDialect>
6676 fidl::encoding::Encode<AudioCompressedFormatAac, D> for &AudioCompressedFormatAac
6677 {
6678 #[inline]
6679 unsafe fn encode(
6680 self,
6681 encoder: &mut fidl::encoding::Encoder<'_, D>,
6682 offset: usize,
6683 _depth: fidl::encoding::Depth,
6684 ) -> fidl::Result<()> {
6685 encoder.debug_check_bounds::<AudioCompressedFormatAac>(offset);
6686 encoder.write_num(0u8, offset);
6687 Ok(())
6688 }
6689 }
6690
6691 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6692 for AudioCompressedFormatAac
6693 {
6694 #[inline(always)]
6695 fn new_empty() -> Self {
6696 Self
6697 }
6698
6699 #[inline]
6700 unsafe fn decode(
6701 &mut self,
6702 decoder: &mut fidl::encoding::Decoder<'_, D>,
6703 offset: usize,
6704 _depth: fidl::encoding::Depth,
6705 ) -> fidl::Result<()> {
6706 decoder.debug_check_bounds::<Self>(offset);
6707 match decoder.read_num::<u8>(offset) {
6708 0 => Ok(()),
6709 _ => Err(fidl::Error::Invalid),
6710 }
6711 }
6712 }
6713
6714 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatSbc {
6715 type Borrowed<'a> = &'a Self;
6716 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6717 value
6718 }
6719 }
6720
6721 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatSbc {
6722 type Owned = Self;
6723
6724 #[inline(always)]
6725 fn inline_align(_context: fidl::encoding::Context) -> usize {
6726 1
6727 }
6728
6729 #[inline(always)]
6730 fn inline_size(_context: fidl::encoding::Context) -> usize {
6731 1
6732 }
6733 }
6734
6735 unsafe impl<D: fidl::encoding::ResourceDialect>
6736 fidl::encoding::Encode<AudioCompressedFormatSbc, D> for &AudioCompressedFormatSbc
6737 {
6738 #[inline]
6739 unsafe fn encode(
6740 self,
6741 encoder: &mut fidl::encoding::Encoder<'_, D>,
6742 offset: usize,
6743 _depth: fidl::encoding::Depth,
6744 ) -> fidl::Result<()> {
6745 encoder.debug_check_bounds::<AudioCompressedFormatSbc>(offset);
6746 encoder.write_num(0u8, offset);
6747 Ok(())
6748 }
6749 }
6750
6751 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6752 for AudioCompressedFormatSbc
6753 {
6754 #[inline(always)]
6755 fn new_empty() -> Self {
6756 Self
6757 }
6758
6759 #[inline]
6760 unsafe fn decode(
6761 &mut self,
6762 decoder: &mut fidl::encoding::Decoder<'_, D>,
6763 offset: usize,
6764 _depth: fidl::encoding::Depth,
6765 ) -> fidl::Result<()> {
6766 decoder.debug_check_bounds::<Self>(offset);
6767 match decoder.read_num::<u8>(offset) {
6768 0 => Ok(()),
6769 _ => Err(fidl::Error::Invalid),
6770 }
6771 }
6772 }
6773
6774 impl fidl::encoding::ValueTypeMarker for AudioConsumerSetRateRequest {
6775 type Borrowed<'a> = &'a Self;
6776 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6777 value
6778 }
6779 }
6780
6781 unsafe impl fidl::encoding::TypeMarker for AudioConsumerSetRateRequest {
6782 type Owned = Self;
6783
6784 #[inline(always)]
6785 fn inline_align(_context: fidl::encoding::Context) -> usize {
6786 4
6787 }
6788
6789 #[inline(always)]
6790 fn inline_size(_context: fidl::encoding::Context) -> usize {
6791 4
6792 }
6793 }
6794
6795 unsafe impl<D: fidl::encoding::ResourceDialect>
6796 fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for &AudioConsumerSetRateRequest
6797 {
6798 #[inline]
6799 unsafe fn encode(
6800 self,
6801 encoder: &mut fidl::encoding::Encoder<'_, D>,
6802 offset: usize,
6803 _depth: fidl::encoding::Depth,
6804 ) -> fidl::Result<()> {
6805 encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6806 fidl::encoding::Encode::<AudioConsumerSetRateRequest, D>::encode(
6808 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.rate),),
6809 encoder,
6810 offset,
6811 _depth,
6812 )
6813 }
6814 }
6815 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
6816 fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for (T0,)
6817 {
6818 #[inline]
6819 unsafe fn encode(
6820 self,
6821 encoder: &mut fidl::encoding::Encoder<'_, D>,
6822 offset: usize,
6823 depth: fidl::encoding::Depth,
6824 ) -> fidl::Result<()> {
6825 encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6826 self.0.encode(encoder, offset + 0, depth)?;
6830 Ok(())
6831 }
6832 }
6833
6834 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6835 for AudioConsumerSetRateRequest
6836 {
6837 #[inline(always)]
6838 fn new_empty() -> Self {
6839 Self { rate: fidl::new_empty!(f32, D) }
6840 }
6841
6842 #[inline]
6843 unsafe fn decode(
6844 &mut self,
6845 decoder: &mut fidl::encoding::Decoder<'_, D>,
6846 offset: usize,
6847 _depth: fidl::encoding::Depth,
6848 ) -> fidl::Result<()> {
6849 decoder.debug_check_bounds::<Self>(offset);
6850 fidl::decode!(f32, D, &mut self.rate, decoder, offset + 0, _depth)?;
6852 Ok(())
6853 }
6854 }
6855
6856 impl fidl::encoding::ValueTypeMarker for AudioConsumerStartRequest {
6857 type Borrowed<'a> = &'a Self;
6858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6859 value
6860 }
6861 }
6862
6863 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartRequest {
6864 type Owned = Self;
6865
6866 #[inline(always)]
6867 fn inline_align(_context: fidl::encoding::Context) -> usize {
6868 8
6869 }
6870
6871 #[inline(always)]
6872 fn inline_size(_context: fidl::encoding::Context) -> usize {
6873 24
6874 }
6875 }
6876
6877 unsafe impl<D: fidl::encoding::ResourceDialect>
6878 fidl::encoding::Encode<AudioConsumerStartRequest, D> for &AudioConsumerStartRequest
6879 {
6880 #[inline]
6881 unsafe fn encode(
6882 self,
6883 encoder: &mut fidl::encoding::Encoder<'_, D>,
6884 offset: usize,
6885 _depth: fidl::encoding::Depth,
6886 ) -> fidl::Result<()> {
6887 encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6888 fidl::encoding::Encode::<AudioConsumerStartRequest, D>::encode(
6890 (
6891 <AudioConsumerStartFlags as fidl::encoding::ValueTypeMarker>::borrow(
6892 &self.flags,
6893 ),
6894 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.reference_time),
6895 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.media_time),
6896 ),
6897 encoder,
6898 offset,
6899 _depth,
6900 )
6901 }
6902 }
6903 unsafe impl<
6904 D: fidl::encoding::ResourceDialect,
6905 T0: fidl::encoding::Encode<AudioConsumerStartFlags, D>,
6906 T1: fidl::encoding::Encode<i64, D>,
6907 T2: fidl::encoding::Encode<i64, D>,
6908 > fidl::encoding::Encode<AudioConsumerStartRequest, D> for (T0, T1, T2)
6909 {
6910 #[inline]
6911 unsafe fn encode(
6912 self,
6913 encoder: &mut fidl::encoding::Encoder<'_, D>,
6914 offset: usize,
6915 depth: fidl::encoding::Depth,
6916 ) -> fidl::Result<()> {
6917 encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6918 unsafe {
6921 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6922 (ptr as *mut u64).write_unaligned(0);
6923 }
6924 self.0.encode(encoder, offset + 0, depth)?;
6926 self.1.encode(encoder, offset + 8, depth)?;
6927 self.2.encode(encoder, offset + 16, depth)?;
6928 Ok(())
6929 }
6930 }
6931
6932 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6933 for AudioConsumerStartRequest
6934 {
6935 #[inline(always)]
6936 fn new_empty() -> Self {
6937 Self {
6938 flags: fidl::new_empty!(AudioConsumerStartFlags, D),
6939 reference_time: fidl::new_empty!(i64, D),
6940 media_time: fidl::new_empty!(i64, D),
6941 }
6942 }
6943
6944 #[inline]
6945 unsafe fn decode(
6946 &mut self,
6947 decoder: &mut fidl::encoding::Decoder<'_, D>,
6948 offset: usize,
6949 _depth: fidl::encoding::Depth,
6950 ) -> fidl::Result<()> {
6951 decoder.debug_check_bounds::<Self>(offset);
6952 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
6954 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6955 let mask = 0xffffffff00000000u64;
6956 let maskedval = padval & mask;
6957 if maskedval != 0 {
6958 return Err(fidl::Error::NonZeroPadding {
6959 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
6960 });
6961 }
6962 fidl::decode!(
6963 AudioConsumerStartFlags,
6964 D,
6965 &mut self.flags,
6966 decoder,
6967 offset + 0,
6968 _depth
6969 )?;
6970 fidl::decode!(i64, D, &mut self.reference_time, decoder, offset + 8, _depth)?;
6971 fidl::decode!(i64, D, &mut self.media_time, decoder, offset + 16, _depth)?;
6972 Ok(())
6973 }
6974 }
6975
6976 impl fidl::encoding::ValueTypeMarker for AudioConsumerWatchStatusResponse {
6977 type Borrowed<'a> = &'a Self;
6978 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6979 value
6980 }
6981 }
6982
6983 unsafe impl fidl::encoding::TypeMarker for AudioConsumerWatchStatusResponse {
6984 type Owned = Self;
6985
6986 #[inline(always)]
6987 fn inline_align(_context: fidl::encoding::Context) -> usize {
6988 8
6989 }
6990
6991 #[inline(always)]
6992 fn inline_size(_context: fidl::encoding::Context) -> usize {
6993 16
6994 }
6995 }
6996
6997 unsafe impl<D: fidl::encoding::ResourceDialect>
6998 fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D>
6999 for &AudioConsumerWatchStatusResponse
7000 {
7001 #[inline]
7002 unsafe fn encode(
7003 self,
7004 encoder: &mut fidl::encoding::Encoder<'_, D>,
7005 offset: usize,
7006 _depth: fidl::encoding::Depth,
7007 ) -> fidl::Result<()> {
7008 encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
7009 fidl::encoding::Encode::<AudioConsumerWatchStatusResponse, D>::encode(
7011 (<AudioConsumerStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
7012 encoder,
7013 offset,
7014 _depth,
7015 )
7016 }
7017 }
7018 unsafe impl<
7019 D: fidl::encoding::ResourceDialect,
7020 T0: fidl::encoding::Encode<AudioConsumerStatus, D>,
7021 > fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D> for (T0,)
7022 {
7023 #[inline]
7024 unsafe fn encode(
7025 self,
7026 encoder: &mut fidl::encoding::Encoder<'_, D>,
7027 offset: usize,
7028 depth: fidl::encoding::Depth,
7029 ) -> fidl::Result<()> {
7030 encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
7031 self.0.encode(encoder, offset + 0, depth)?;
7035 Ok(())
7036 }
7037 }
7038
7039 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7040 for AudioConsumerWatchStatusResponse
7041 {
7042 #[inline(always)]
7043 fn new_empty() -> Self {
7044 Self { status: fidl::new_empty!(AudioConsumerStatus, D) }
7045 }
7046
7047 #[inline]
7048 unsafe fn decode(
7049 &mut self,
7050 decoder: &mut fidl::encoding::Decoder<'_, D>,
7051 offset: usize,
7052 _depth: fidl::encoding::Depth,
7053 ) -> fidl::Result<()> {
7054 decoder.debug_check_bounds::<Self>(offset);
7055 fidl::decode!(AudioConsumerStatus, D, &mut self.status, decoder, offset + 0, _depth)?;
7057 Ok(())
7058 }
7059 }
7060
7061 impl fidl::encoding::ValueTypeMarker for AudioCoreEnableDeviceSettingsRequest {
7062 type Borrowed<'a> = &'a Self;
7063 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7064 value
7065 }
7066 }
7067
7068 unsafe impl fidl::encoding::TypeMarker for AudioCoreEnableDeviceSettingsRequest {
7069 type Owned = Self;
7070
7071 #[inline(always)]
7072 fn inline_align(_context: fidl::encoding::Context) -> usize {
7073 1
7074 }
7075
7076 #[inline(always)]
7077 fn inline_size(_context: fidl::encoding::Context) -> usize {
7078 1
7079 }
7080 }
7081
7082 unsafe impl<D: fidl::encoding::ResourceDialect>
7083 fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D>
7084 for &AudioCoreEnableDeviceSettingsRequest
7085 {
7086 #[inline]
7087 unsafe fn encode(
7088 self,
7089 encoder: &mut fidl::encoding::Encoder<'_, D>,
7090 offset: usize,
7091 _depth: fidl::encoding::Depth,
7092 ) -> fidl::Result<()> {
7093 encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
7094 fidl::encoding::Encode::<AudioCoreEnableDeviceSettingsRequest, D>::encode(
7096 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
7097 encoder,
7098 offset,
7099 _depth,
7100 )
7101 }
7102 }
7103 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
7104 fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D> for (T0,)
7105 {
7106 #[inline]
7107 unsafe fn encode(
7108 self,
7109 encoder: &mut fidl::encoding::Encoder<'_, D>,
7110 offset: usize,
7111 depth: fidl::encoding::Depth,
7112 ) -> fidl::Result<()> {
7113 encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
7114 self.0.encode(encoder, offset + 0, depth)?;
7118 Ok(())
7119 }
7120 }
7121
7122 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7123 for AudioCoreEnableDeviceSettingsRequest
7124 {
7125 #[inline(always)]
7126 fn new_empty() -> Self {
7127 Self { enabled: fidl::new_empty!(bool, D) }
7128 }
7129
7130 #[inline]
7131 unsafe fn decode(
7132 &mut self,
7133 decoder: &mut fidl::encoding::Decoder<'_, D>,
7134 offset: usize,
7135 _depth: fidl::encoding::Depth,
7136 ) -> fidl::Result<()> {
7137 decoder.debug_check_bounds::<Self>(offset);
7138 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
7140 Ok(())
7141 }
7142 }
7143
7144 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Request {
7145 type Borrowed<'a> = &'a Self;
7146 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7147 value
7148 }
7149 }
7150
7151 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Request {
7152 type Owned = Self;
7153
7154 #[inline(always)]
7155 fn inline_align(_context: fidl::encoding::Context) -> usize {
7156 8
7157 }
7158
7159 #[inline(always)]
7160 fn inline_size(_context: fidl::encoding::Context) -> usize {
7161 24
7162 }
7163 }
7164
7165 unsafe impl<D: fidl::encoding::ResourceDialect>
7166 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D>
7167 for &AudioCoreGetDbFromVolume2Request
7168 {
7169 #[inline]
7170 unsafe fn encode(
7171 self,
7172 encoder: &mut fidl::encoding::Encoder<'_, D>,
7173 offset: usize,
7174 _depth: fidl::encoding::Depth,
7175 ) -> fidl::Result<()> {
7176 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
7177 fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Request, D>::encode(
7179 (
7180 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7181 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
7182 ),
7183 encoder,
7184 offset,
7185 _depth,
7186 )
7187 }
7188 }
7189 unsafe impl<
7190 D: fidl::encoding::ResourceDialect,
7191 T0: fidl::encoding::Encode<Usage2, D>,
7192 T1: fidl::encoding::Encode<f32, D>,
7193 > fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D> for (T0, T1)
7194 {
7195 #[inline]
7196 unsafe fn encode(
7197 self,
7198 encoder: &mut fidl::encoding::Encoder<'_, D>,
7199 offset: usize,
7200 depth: fidl::encoding::Depth,
7201 ) -> fidl::Result<()> {
7202 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
7203 unsafe {
7206 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7207 (ptr as *mut u64).write_unaligned(0);
7208 }
7209 self.0.encode(encoder, offset + 0, depth)?;
7211 self.1.encode(encoder, offset + 16, depth)?;
7212 Ok(())
7213 }
7214 }
7215
7216 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7217 for AudioCoreGetDbFromVolume2Request
7218 {
7219 #[inline(always)]
7220 fn new_empty() -> Self {
7221 Self { usage: fidl::new_empty!(Usage2, D), volume: fidl::new_empty!(f32, D) }
7222 }
7223
7224 #[inline]
7225 unsafe fn decode(
7226 &mut self,
7227 decoder: &mut fidl::encoding::Decoder<'_, D>,
7228 offset: usize,
7229 _depth: fidl::encoding::Depth,
7230 ) -> fidl::Result<()> {
7231 decoder.debug_check_bounds::<Self>(offset);
7232 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7234 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7235 let mask = 0xffffffff00000000u64;
7236 let maskedval = padval & mask;
7237 if maskedval != 0 {
7238 return Err(fidl::Error::NonZeroPadding {
7239 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7240 });
7241 }
7242 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7243 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7244 Ok(())
7245 }
7246 }
7247
7248 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeRequest {
7249 type Borrowed<'a> = &'a Self;
7250 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7251 value
7252 }
7253 }
7254
7255 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeRequest {
7256 type Owned = Self;
7257
7258 #[inline(always)]
7259 fn inline_align(_context: fidl::encoding::Context) -> usize {
7260 8
7261 }
7262
7263 #[inline(always)]
7264 fn inline_size(_context: fidl::encoding::Context) -> usize {
7265 24
7266 }
7267 }
7268
7269 unsafe impl<D: fidl::encoding::ResourceDialect>
7270 fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D>
7271 for &AudioCoreGetDbFromVolumeRequest
7272 {
7273 #[inline]
7274 unsafe fn encode(
7275 self,
7276 encoder: &mut fidl::encoding::Encoder<'_, D>,
7277 offset: usize,
7278 _depth: fidl::encoding::Depth,
7279 ) -> fidl::Result<()> {
7280 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeRequest>(offset);
7281 fidl::encoding::Encode::<AudioCoreGetDbFromVolumeRequest, D>::encode(
7283 (
7284 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7285 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
7286 ),
7287 encoder,
7288 offset,
7289 _depth,
7290 )
7291 }
7292 }
7293 unsafe impl<
7294 D: fidl::encoding::ResourceDialect,
7295 T0: fidl::encoding::Encode<Usage, D>,
7296 T1: fidl::encoding::Encode<f32, D>,
7297 > fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D> for (T0, T1)
7298 {
7299 #[inline]
7300 unsafe fn encode(
7301 self,
7302 encoder: &mut fidl::encoding::Encoder<'_, D>,
7303 offset: usize,
7304 depth: fidl::encoding::Depth,
7305 ) -> fidl::Result<()> {
7306 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeRequest>(offset);
7307 unsafe {
7310 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7311 (ptr as *mut u64).write_unaligned(0);
7312 }
7313 self.0.encode(encoder, offset + 0, depth)?;
7315 self.1.encode(encoder, offset + 16, depth)?;
7316 Ok(())
7317 }
7318 }
7319
7320 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7321 for AudioCoreGetDbFromVolumeRequest
7322 {
7323 #[inline(always)]
7324 fn new_empty() -> Self {
7325 Self { usage: fidl::new_empty!(Usage, D), volume: fidl::new_empty!(f32, D) }
7326 }
7327
7328 #[inline]
7329 unsafe fn decode(
7330 &mut self,
7331 decoder: &mut fidl::encoding::Decoder<'_, D>,
7332 offset: usize,
7333 _depth: fidl::encoding::Depth,
7334 ) -> fidl::Result<()> {
7335 decoder.debug_check_bounds::<Self>(offset);
7336 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7338 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7339 let mask = 0xffffffff00000000u64;
7340 let maskedval = padval & mask;
7341 if maskedval != 0 {
7342 return Err(fidl::Error::NonZeroPadding {
7343 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7344 });
7345 }
7346 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7347 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7348 Ok(())
7349 }
7350 }
7351
7352 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeResponse {
7353 type Borrowed<'a> = &'a Self;
7354 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7355 value
7356 }
7357 }
7358
7359 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeResponse {
7360 type Owned = Self;
7361
7362 #[inline(always)]
7363 fn inline_align(_context: fidl::encoding::Context) -> usize {
7364 4
7365 }
7366
7367 #[inline(always)]
7368 fn inline_size(_context: fidl::encoding::Context) -> usize {
7369 4
7370 }
7371 }
7372
7373 unsafe impl<D: fidl::encoding::ResourceDialect>
7374 fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D>
7375 for &AudioCoreGetDbFromVolumeResponse
7376 {
7377 #[inline]
7378 unsafe fn encode(
7379 self,
7380 encoder: &mut fidl::encoding::Encoder<'_, D>,
7381 offset: usize,
7382 _depth: fidl::encoding::Depth,
7383 ) -> fidl::Result<()> {
7384 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7385 fidl::encoding::Encode::<AudioCoreGetDbFromVolumeResponse, D>::encode(
7387 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
7388 encoder,
7389 offset,
7390 _depth,
7391 )
7392 }
7393 }
7394 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7395 fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D> for (T0,)
7396 {
7397 #[inline]
7398 unsafe fn encode(
7399 self,
7400 encoder: &mut fidl::encoding::Encoder<'_, D>,
7401 offset: usize,
7402 depth: fidl::encoding::Depth,
7403 ) -> fidl::Result<()> {
7404 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7405 self.0.encode(encoder, offset + 0, depth)?;
7409 Ok(())
7410 }
7411 }
7412
7413 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7414 for AudioCoreGetDbFromVolumeResponse
7415 {
7416 #[inline(always)]
7417 fn new_empty() -> Self {
7418 Self { gain_db: fidl::new_empty!(f32, D) }
7419 }
7420
7421 #[inline]
7422 unsafe fn decode(
7423 &mut self,
7424 decoder: &mut fidl::encoding::Decoder<'_, D>,
7425 offset: usize,
7426 _depth: fidl::encoding::Depth,
7427 ) -> fidl::Result<()> {
7428 decoder.debug_check_bounds::<Self>(offset);
7429 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
7431 Ok(())
7432 }
7433 }
7434
7435 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Request {
7436 type Borrowed<'a> = &'a Self;
7437 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7438 value
7439 }
7440 }
7441
7442 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Request {
7443 type Owned = Self;
7444
7445 #[inline(always)]
7446 fn inline_align(_context: fidl::encoding::Context) -> usize {
7447 8
7448 }
7449
7450 #[inline(always)]
7451 fn inline_size(_context: fidl::encoding::Context) -> usize {
7452 24
7453 }
7454 }
7455
7456 unsafe impl<D: fidl::encoding::ResourceDialect>
7457 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D>
7458 for &AudioCoreGetVolumeFromDb2Request
7459 {
7460 #[inline]
7461 unsafe fn encode(
7462 self,
7463 encoder: &mut fidl::encoding::Encoder<'_, D>,
7464 offset: usize,
7465 _depth: fidl::encoding::Depth,
7466 ) -> fidl::Result<()> {
7467 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7468 fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Request, D>::encode(
7470 (
7471 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7472 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7473 ),
7474 encoder,
7475 offset,
7476 _depth,
7477 )
7478 }
7479 }
7480 unsafe impl<
7481 D: fidl::encoding::ResourceDialect,
7482 T0: fidl::encoding::Encode<Usage2, D>,
7483 T1: fidl::encoding::Encode<f32, D>,
7484 > fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D> for (T0, T1)
7485 {
7486 #[inline]
7487 unsafe fn encode(
7488 self,
7489 encoder: &mut fidl::encoding::Encoder<'_, D>,
7490 offset: usize,
7491 depth: fidl::encoding::Depth,
7492 ) -> fidl::Result<()> {
7493 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7494 unsafe {
7497 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7498 (ptr as *mut u64).write_unaligned(0);
7499 }
7500 self.0.encode(encoder, offset + 0, depth)?;
7502 self.1.encode(encoder, offset + 16, depth)?;
7503 Ok(())
7504 }
7505 }
7506
7507 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7508 for AudioCoreGetVolumeFromDb2Request
7509 {
7510 #[inline(always)]
7511 fn new_empty() -> Self {
7512 Self { usage: fidl::new_empty!(Usage2, D), gain_db: fidl::new_empty!(f32, D) }
7513 }
7514
7515 #[inline]
7516 unsafe fn decode(
7517 &mut self,
7518 decoder: &mut fidl::encoding::Decoder<'_, D>,
7519 offset: usize,
7520 _depth: fidl::encoding::Depth,
7521 ) -> fidl::Result<()> {
7522 decoder.debug_check_bounds::<Self>(offset);
7523 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7525 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7526 let mask = 0xffffffff00000000u64;
7527 let maskedval = padval & mask;
7528 if maskedval != 0 {
7529 return Err(fidl::Error::NonZeroPadding {
7530 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7531 });
7532 }
7533 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7534 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7535 Ok(())
7536 }
7537 }
7538
7539 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbRequest {
7540 type Borrowed<'a> = &'a Self;
7541 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7542 value
7543 }
7544 }
7545
7546 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbRequest {
7547 type Owned = Self;
7548
7549 #[inline(always)]
7550 fn inline_align(_context: fidl::encoding::Context) -> usize {
7551 8
7552 }
7553
7554 #[inline(always)]
7555 fn inline_size(_context: fidl::encoding::Context) -> usize {
7556 24
7557 }
7558 }
7559
7560 unsafe impl<D: fidl::encoding::ResourceDialect>
7561 fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D>
7562 for &AudioCoreGetVolumeFromDbRequest
7563 {
7564 #[inline]
7565 unsafe fn encode(
7566 self,
7567 encoder: &mut fidl::encoding::Encoder<'_, D>,
7568 offset: usize,
7569 _depth: fidl::encoding::Depth,
7570 ) -> fidl::Result<()> {
7571 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbRequest>(offset);
7572 fidl::encoding::Encode::<AudioCoreGetVolumeFromDbRequest, D>::encode(
7574 (
7575 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7576 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7577 ),
7578 encoder,
7579 offset,
7580 _depth,
7581 )
7582 }
7583 }
7584 unsafe impl<
7585 D: fidl::encoding::ResourceDialect,
7586 T0: fidl::encoding::Encode<Usage, D>,
7587 T1: fidl::encoding::Encode<f32, D>,
7588 > fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D> for (T0, T1)
7589 {
7590 #[inline]
7591 unsafe fn encode(
7592 self,
7593 encoder: &mut fidl::encoding::Encoder<'_, D>,
7594 offset: usize,
7595 depth: fidl::encoding::Depth,
7596 ) -> fidl::Result<()> {
7597 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbRequest>(offset);
7598 unsafe {
7601 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7602 (ptr as *mut u64).write_unaligned(0);
7603 }
7604 self.0.encode(encoder, offset + 0, depth)?;
7606 self.1.encode(encoder, offset + 16, depth)?;
7607 Ok(())
7608 }
7609 }
7610
7611 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7612 for AudioCoreGetVolumeFromDbRequest
7613 {
7614 #[inline(always)]
7615 fn new_empty() -> Self {
7616 Self { usage: fidl::new_empty!(Usage, D), gain_db: fidl::new_empty!(f32, D) }
7617 }
7618
7619 #[inline]
7620 unsafe fn decode(
7621 &mut self,
7622 decoder: &mut fidl::encoding::Decoder<'_, D>,
7623 offset: usize,
7624 _depth: fidl::encoding::Depth,
7625 ) -> fidl::Result<()> {
7626 decoder.debug_check_bounds::<Self>(offset);
7627 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7629 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7630 let mask = 0xffffffff00000000u64;
7631 let maskedval = padval & mask;
7632 if maskedval != 0 {
7633 return Err(fidl::Error::NonZeroPadding {
7634 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7635 });
7636 }
7637 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7638 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7639 Ok(())
7640 }
7641 }
7642
7643 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbResponse {
7644 type Borrowed<'a> = &'a Self;
7645 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7646 value
7647 }
7648 }
7649
7650 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbResponse {
7651 type Owned = Self;
7652
7653 #[inline(always)]
7654 fn inline_align(_context: fidl::encoding::Context) -> usize {
7655 4
7656 }
7657
7658 #[inline(always)]
7659 fn inline_size(_context: fidl::encoding::Context) -> usize {
7660 4
7661 }
7662 }
7663
7664 unsafe impl<D: fidl::encoding::ResourceDialect>
7665 fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D>
7666 for &AudioCoreGetVolumeFromDbResponse
7667 {
7668 #[inline]
7669 unsafe fn encode(
7670 self,
7671 encoder: &mut fidl::encoding::Encoder<'_, D>,
7672 offset: usize,
7673 _depth: fidl::encoding::Depth,
7674 ) -> fidl::Result<()> {
7675 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7676 fidl::encoding::Encode::<AudioCoreGetVolumeFromDbResponse, D>::encode(
7678 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
7679 encoder,
7680 offset,
7681 _depth,
7682 )
7683 }
7684 }
7685 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7686 fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D> for (T0,)
7687 {
7688 #[inline]
7689 unsafe fn encode(
7690 self,
7691 encoder: &mut fidl::encoding::Encoder<'_, D>,
7692 offset: usize,
7693 depth: fidl::encoding::Depth,
7694 ) -> fidl::Result<()> {
7695 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7696 self.0.encode(encoder, offset + 0, depth)?;
7700 Ok(())
7701 }
7702 }
7703
7704 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7705 for AudioCoreGetVolumeFromDbResponse
7706 {
7707 #[inline(always)]
7708 fn new_empty() -> Self {
7709 Self { volume: fidl::new_empty!(f32, D) }
7710 }
7711
7712 #[inline]
7713 unsafe fn decode(
7714 &mut self,
7715 decoder: &mut fidl::encoding::Decoder<'_, D>,
7716 offset: usize,
7717 _depth: fidl::encoding::Depth,
7718 ) -> fidl::Result<()> {
7719 decoder.debug_check_bounds::<Self>(offset);
7720 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
7722 Ok(())
7723 }
7724 }
7725
7726 impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGain2Request {
7727 type Borrowed<'a> = &'a Self;
7728 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7729 value
7730 }
7731 }
7732
7733 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGain2Request {
7734 type Owned = Self;
7735
7736 #[inline(always)]
7737 fn inline_align(_context: fidl::encoding::Context) -> usize {
7738 4
7739 }
7740
7741 #[inline(always)]
7742 fn inline_size(_context: fidl::encoding::Context) -> usize {
7743 8
7744 }
7745 }
7746
7747 unsafe impl<D: fidl::encoding::ResourceDialect>
7748 fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D>
7749 for &AudioCoreSetCaptureUsageGain2Request
7750 {
7751 #[inline]
7752 unsafe fn encode(
7753 self,
7754 encoder: &mut fidl::encoding::Encoder<'_, D>,
7755 offset: usize,
7756 _depth: fidl::encoding::Depth,
7757 ) -> fidl::Result<()> {
7758 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7759 fidl::encoding::Encode::<AudioCoreSetCaptureUsageGain2Request, D>::encode(
7761 (
7762 <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7763 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7764 ),
7765 encoder,
7766 offset,
7767 _depth,
7768 )
7769 }
7770 }
7771 unsafe impl<
7772 D: fidl::encoding::ResourceDialect,
7773 T0: fidl::encoding::Encode<AudioCaptureUsage2, D>,
7774 T1: fidl::encoding::Encode<f32, D>,
7775 > fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D> for (T0, T1)
7776 {
7777 #[inline]
7778 unsafe fn encode(
7779 self,
7780 encoder: &mut fidl::encoding::Encoder<'_, D>,
7781 offset: usize,
7782 depth: fidl::encoding::Depth,
7783 ) -> fidl::Result<()> {
7784 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7785 self.0.encode(encoder, offset + 0, depth)?;
7789 self.1.encode(encoder, offset + 4, depth)?;
7790 Ok(())
7791 }
7792 }
7793
7794 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7795 for AudioCoreSetCaptureUsageGain2Request
7796 {
7797 #[inline(always)]
7798 fn new_empty() -> Self {
7799 Self {
7800 usage: fidl::new_empty!(AudioCaptureUsage2, D),
7801 gain_db: fidl::new_empty!(f32, D),
7802 }
7803 }
7804
7805 #[inline]
7806 unsafe fn decode(
7807 &mut self,
7808 decoder: &mut fidl::encoding::Decoder<'_, D>,
7809 offset: usize,
7810 _depth: fidl::encoding::Depth,
7811 ) -> fidl::Result<()> {
7812 decoder.debug_check_bounds::<Self>(offset);
7813 fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7815 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7816 Ok(())
7817 }
7818 }
7819
7820 impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGainRequest {
7821 type Borrowed<'a> = &'a Self;
7822 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7823 value
7824 }
7825 }
7826
7827 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGainRequest {
7828 type Owned = Self;
7829
7830 #[inline(always)]
7831 fn inline_align(_context: fidl::encoding::Context) -> usize {
7832 4
7833 }
7834
7835 #[inline(always)]
7836 fn inline_size(_context: fidl::encoding::Context) -> usize {
7837 8
7838 }
7839 }
7840
7841 unsafe impl<D: fidl::encoding::ResourceDialect>
7842 fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D>
7843 for &AudioCoreSetCaptureUsageGainRequest
7844 {
7845 #[inline]
7846 unsafe fn encode(
7847 self,
7848 encoder: &mut fidl::encoding::Encoder<'_, D>,
7849 offset: usize,
7850 _depth: fidl::encoding::Depth,
7851 ) -> fidl::Result<()> {
7852 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7853 fidl::encoding::Encode::<AudioCoreSetCaptureUsageGainRequest, D>::encode(
7855 (
7856 <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7857 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7858 ),
7859 encoder,
7860 offset,
7861 _depth,
7862 )
7863 }
7864 }
7865 unsafe impl<
7866 D: fidl::encoding::ResourceDialect,
7867 T0: fidl::encoding::Encode<AudioCaptureUsage, D>,
7868 T1: fidl::encoding::Encode<f32, D>,
7869 > fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D> for (T0, T1)
7870 {
7871 #[inline]
7872 unsafe fn encode(
7873 self,
7874 encoder: &mut fidl::encoding::Encoder<'_, D>,
7875 offset: usize,
7876 depth: fidl::encoding::Depth,
7877 ) -> fidl::Result<()> {
7878 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7879 self.0.encode(encoder, offset + 0, depth)?;
7883 self.1.encode(encoder, offset + 4, depth)?;
7884 Ok(())
7885 }
7886 }
7887
7888 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7889 for AudioCoreSetCaptureUsageGainRequest
7890 {
7891 #[inline(always)]
7892 fn new_empty() -> Self {
7893 Self {
7894 usage: fidl::new_empty!(AudioCaptureUsage, D),
7895 gain_db: fidl::new_empty!(f32, D),
7896 }
7897 }
7898
7899 #[inline]
7900 unsafe fn decode(
7901 &mut self,
7902 decoder: &mut fidl::encoding::Decoder<'_, D>,
7903 offset: usize,
7904 _depth: fidl::encoding::Depth,
7905 ) -> fidl::Result<()> {
7906 decoder.debug_check_bounds::<Self>(offset);
7907 fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7909 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7910 Ok(())
7911 }
7912 }
7913
7914 impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteraction2Request {
7915 type Borrowed<'a> = &'a Self;
7916 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7917 value
7918 }
7919 }
7920
7921 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteraction2Request {
7922 type Owned = Self;
7923
7924 #[inline(always)]
7925 fn inline_align(_context: fidl::encoding::Context) -> usize {
7926 8
7927 }
7928
7929 #[inline(always)]
7930 fn inline_size(_context: fidl::encoding::Context) -> usize {
7931 40
7932 }
7933 }
7934
7935 unsafe impl<D: fidl::encoding::ResourceDialect>
7936 fidl::encoding::Encode<AudioCoreSetInteraction2Request, D>
7937 for &AudioCoreSetInteraction2Request
7938 {
7939 #[inline]
7940 unsafe fn encode(
7941 self,
7942 encoder: &mut fidl::encoding::Encoder<'_, D>,
7943 offset: usize,
7944 _depth: fidl::encoding::Depth,
7945 ) -> fidl::Result<()> {
7946 encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7947 fidl::encoding::Encode::<AudioCoreSetInteraction2Request, D>::encode(
7949 (
7950 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
7951 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
7952 <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
7953 ),
7954 encoder,
7955 offset,
7956 _depth,
7957 )
7958 }
7959 }
7960 unsafe impl<
7961 D: fidl::encoding::ResourceDialect,
7962 T0: fidl::encoding::Encode<Usage2, D>,
7963 T1: fidl::encoding::Encode<Usage2, D>,
7964 T2: fidl::encoding::Encode<Behavior, D>,
7965 > fidl::encoding::Encode<AudioCoreSetInteraction2Request, D> for (T0, T1, T2)
7966 {
7967 #[inline]
7968 unsafe fn encode(
7969 self,
7970 encoder: &mut fidl::encoding::Encoder<'_, D>,
7971 offset: usize,
7972 depth: fidl::encoding::Depth,
7973 ) -> fidl::Result<()> {
7974 encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7975 unsafe {
7978 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7979 (ptr as *mut u64).write_unaligned(0);
7980 }
7981 self.0.encode(encoder, offset + 0, depth)?;
7983 self.1.encode(encoder, offset + 16, depth)?;
7984 self.2.encode(encoder, offset + 32, depth)?;
7985 Ok(())
7986 }
7987 }
7988
7989 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7990 for AudioCoreSetInteraction2Request
7991 {
7992 #[inline(always)]
7993 fn new_empty() -> Self {
7994 Self {
7995 active: fidl::new_empty!(Usage2, D),
7996 affected: fidl::new_empty!(Usage2, D),
7997 behavior: fidl::new_empty!(Behavior, D),
7998 }
7999 }
8000
8001 #[inline]
8002 unsafe fn decode(
8003 &mut self,
8004 decoder: &mut fidl::encoding::Decoder<'_, D>,
8005 offset: usize,
8006 _depth: fidl::encoding::Depth,
8007 ) -> fidl::Result<()> {
8008 decoder.debug_check_bounds::<Self>(offset);
8009 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
8011 let padval = unsafe { (ptr as *const u64).read_unaligned() };
8012 let mask = 0xffffffff00000000u64;
8013 let maskedval = padval & mask;
8014 if maskedval != 0 {
8015 return Err(fidl::Error::NonZeroPadding {
8016 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
8017 });
8018 }
8019 fidl::decode!(Usage2, D, &mut self.active, decoder, offset + 0, _depth)?;
8020 fidl::decode!(Usage2, D, &mut self.affected, decoder, offset + 16, _depth)?;
8021 fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
8022 Ok(())
8023 }
8024 }
8025
8026 impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteractionRequest {
8027 type Borrowed<'a> = &'a Self;
8028 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8029 value
8030 }
8031 }
8032
8033 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteractionRequest {
8034 type Owned = Self;
8035
8036 #[inline(always)]
8037 fn inline_align(_context: fidl::encoding::Context) -> usize {
8038 8
8039 }
8040
8041 #[inline(always)]
8042 fn inline_size(_context: fidl::encoding::Context) -> usize {
8043 40
8044 }
8045 }
8046
8047 unsafe impl<D: fidl::encoding::ResourceDialect>
8048 fidl::encoding::Encode<AudioCoreSetInteractionRequest, D>
8049 for &AudioCoreSetInteractionRequest
8050 {
8051 #[inline]
8052 unsafe fn encode(
8053 self,
8054 encoder: &mut fidl::encoding::Encoder<'_, D>,
8055 offset: usize,
8056 _depth: fidl::encoding::Depth,
8057 ) -> fidl::Result<()> {
8058 encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
8059 fidl::encoding::Encode::<AudioCoreSetInteractionRequest, D>::encode(
8061 (
8062 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
8063 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
8064 <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
8065 ),
8066 encoder,
8067 offset,
8068 _depth,
8069 )
8070 }
8071 }
8072 unsafe impl<
8073 D: fidl::encoding::ResourceDialect,
8074 T0: fidl::encoding::Encode<Usage, D>,
8075 T1: fidl::encoding::Encode<Usage, D>,
8076 T2: fidl::encoding::Encode<Behavior, D>,
8077 > fidl::encoding::Encode<AudioCoreSetInteractionRequest, D> for (T0, T1, T2)
8078 {
8079 #[inline]
8080 unsafe fn encode(
8081 self,
8082 encoder: &mut fidl::encoding::Encoder<'_, D>,
8083 offset: usize,
8084 depth: fidl::encoding::Depth,
8085 ) -> fidl::Result<()> {
8086 encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
8087 unsafe {
8090 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
8091 (ptr as *mut u64).write_unaligned(0);
8092 }
8093 self.0.encode(encoder, offset + 0, depth)?;
8095 self.1.encode(encoder, offset + 16, depth)?;
8096 self.2.encode(encoder, offset + 32, depth)?;
8097 Ok(())
8098 }
8099 }
8100
8101 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8102 for AudioCoreSetInteractionRequest
8103 {
8104 #[inline(always)]
8105 fn new_empty() -> Self {
8106 Self {
8107 active: fidl::new_empty!(Usage, D),
8108 affected: fidl::new_empty!(Usage, D),
8109 behavior: fidl::new_empty!(Behavior, D),
8110 }
8111 }
8112
8113 #[inline]
8114 unsafe fn decode(
8115 &mut self,
8116 decoder: &mut fidl::encoding::Decoder<'_, D>,
8117 offset: usize,
8118 _depth: fidl::encoding::Depth,
8119 ) -> fidl::Result<()> {
8120 decoder.debug_check_bounds::<Self>(offset);
8121 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
8123 let padval = unsafe { (ptr as *const u64).read_unaligned() };
8124 let mask = 0xffffffff00000000u64;
8125 let maskedval = padval & mask;
8126 if maskedval != 0 {
8127 return Err(fidl::Error::NonZeroPadding {
8128 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
8129 });
8130 }
8131 fidl::decode!(Usage, D, &mut self.active, decoder, offset + 0, _depth)?;
8132 fidl::decode!(Usage, D, &mut self.affected, decoder, offset + 16, _depth)?;
8133 fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
8134 Ok(())
8135 }
8136 }
8137
8138 impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGain2Request {
8139 type Borrowed<'a> = &'a Self;
8140 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8141 value
8142 }
8143 }
8144
8145 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGain2Request {
8146 type Owned = Self;
8147
8148 #[inline(always)]
8149 fn inline_align(_context: fidl::encoding::Context) -> usize {
8150 4
8151 }
8152
8153 #[inline(always)]
8154 fn inline_size(_context: fidl::encoding::Context) -> usize {
8155 8
8156 }
8157 }
8158
8159 unsafe impl<D: fidl::encoding::ResourceDialect>
8160 fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D>
8161 for &AudioCoreSetRenderUsageGain2Request
8162 {
8163 #[inline]
8164 unsafe fn encode(
8165 self,
8166 encoder: &mut fidl::encoding::Encoder<'_, D>,
8167 offset: usize,
8168 _depth: fidl::encoding::Depth,
8169 ) -> fidl::Result<()> {
8170 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
8171 fidl::encoding::Encode::<AudioCoreSetRenderUsageGain2Request, D>::encode(
8173 (
8174 <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
8175 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
8176 ),
8177 encoder,
8178 offset,
8179 _depth,
8180 )
8181 }
8182 }
8183 unsafe impl<
8184 D: fidl::encoding::ResourceDialect,
8185 T0: fidl::encoding::Encode<AudioRenderUsage2, D>,
8186 T1: fidl::encoding::Encode<f32, D>,
8187 > fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D> for (T0, T1)
8188 {
8189 #[inline]
8190 unsafe fn encode(
8191 self,
8192 encoder: &mut fidl::encoding::Encoder<'_, D>,
8193 offset: usize,
8194 depth: fidl::encoding::Depth,
8195 ) -> fidl::Result<()> {
8196 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
8197 self.0.encode(encoder, offset + 0, depth)?;
8201 self.1.encode(encoder, offset + 4, depth)?;
8202 Ok(())
8203 }
8204 }
8205
8206 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8207 for AudioCoreSetRenderUsageGain2Request
8208 {
8209 #[inline(always)]
8210 fn new_empty() -> Self {
8211 Self {
8212 usage: fidl::new_empty!(AudioRenderUsage2, D),
8213 gain_db: fidl::new_empty!(f32, D),
8214 }
8215 }
8216
8217 #[inline]
8218 unsafe fn decode(
8219 &mut self,
8220 decoder: &mut fidl::encoding::Decoder<'_, D>,
8221 offset: usize,
8222 _depth: fidl::encoding::Depth,
8223 ) -> fidl::Result<()> {
8224 decoder.debug_check_bounds::<Self>(offset);
8225 fidl::decode!(AudioRenderUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
8227 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8228 Ok(())
8229 }
8230 }
8231
8232 impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGainRequest {
8233 type Borrowed<'a> = &'a Self;
8234 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8235 value
8236 }
8237 }
8238
8239 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGainRequest {
8240 type Owned = Self;
8241
8242 #[inline(always)]
8243 fn inline_align(_context: fidl::encoding::Context) -> usize {
8244 4
8245 }
8246
8247 #[inline(always)]
8248 fn inline_size(_context: fidl::encoding::Context) -> usize {
8249 8
8250 }
8251 }
8252
8253 unsafe impl<D: fidl::encoding::ResourceDialect>
8254 fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D>
8255 for &AudioCoreSetRenderUsageGainRequest
8256 {
8257 #[inline]
8258 unsafe fn encode(
8259 self,
8260 encoder: &mut fidl::encoding::Encoder<'_, D>,
8261 offset: usize,
8262 _depth: fidl::encoding::Depth,
8263 ) -> fidl::Result<()> {
8264 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8265 fidl::encoding::Encode::<AudioCoreSetRenderUsageGainRequest, D>::encode(
8267 (
8268 <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
8269 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
8270 ),
8271 encoder,
8272 offset,
8273 _depth,
8274 )
8275 }
8276 }
8277 unsafe impl<
8278 D: fidl::encoding::ResourceDialect,
8279 T0: fidl::encoding::Encode<AudioRenderUsage, D>,
8280 T1: fidl::encoding::Encode<f32, D>,
8281 > fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D> for (T0, T1)
8282 {
8283 #[inline]
8284 unsafe fn encode(
8285 self,
8286 encoder: &mut fidl::encoding::Encoder<'_, D>,
8287 offset: usize,
8288 depth: fidl::encoding::Depth,
8289 ) -> fidl::Result<()> {
8290 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8291 self.0.encode(encoder, offset + 0, depth)?;
8295 self.1.encode(encoder, offset + 4, depth)?;
8296 Ok(())
8297 }
8298 }
8299
8300 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8301 for AudioCoreSetRenderUsageGainRequest
8302 {
8303 #[inline(always)]
8304 fn new_empty() -> Self {
8305 Self { usage: fidl::new_empty!(AudioRenderUsage, D), gain_db: fidl::new_empty!(f32, D) }
8306 }
8307
8308 #[inline]
8309 unsafe fn decode(
8310 &mut self,
8311 decoder: &mut fidl::encoding::Decoder<'_, D>,
8312 offset: usize,
8313 _depth: fidl::encoding::Depth,
8314 ) -> fidl::Result<()> {
8315 decoder.debug_check_bounds::<Self>(offset);
8316 fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
8318 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8319 Ok(())
8320 }
8321 }
8322
8323 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Response {
8324 type Borrowed<'a> = &'a Self;
8325 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8326 value
8327 }
8328 }
8329
8330 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Response {
8331 type Owned = Self;
8332
8333 #[inline(always)]
8334 fn inline_align(_context: fidl::encoding::Context) -> usize {
8335 4
8336 }
8337
8338 #[inline(always)]
8339 fn inline_size(_context: fidl::encoding::Context) -> usize {
8340 4
8341 }
8342 }
8343
8344 unsafe impl<D: fidl::encoding::ResourceDialect>
8345 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D>
8346 for &AudioCoreGetDbFromVolume2Response
8347 {
8348 #[inline]
8349 unsafe fn encode(
8350 self,
8351 encoder: &mut fidl::encoding::Encoder<'_, D>,
8352 offset: usize,
8353 _depth: fidl::encoding::Depth,
8354 ) -> fidl::Result<()> {
8355 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8356 fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Response, D>::encode(
8358 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
8359 encoder,
8360 offset,
8361 _depth,
8362 )
8363 }
8364 }
8365 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8366 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D> for (T0,)
8367 {
8368 #[inline]
8369 unsafe fn encode(
8370 self,
8371 encoder: &mut fidl::encoding::Encoder<'_, D>,
8372 offset: usize,
8373 depth: fidl::encoding::Depth,
8374 ) -> fidl::Result<()> {
8375 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8376 self.0.encode(encoder, offset + 0, depth)?;
8380 Ok(())
8381 }
8382 }
8383
8384 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8385 for AudioCoreGetDbFromVolume2Response
8386 {
8387 #[inline(always)]
8388 fn new_empty() -> Self {
8389 Self { gain_db: fidl::new_empty!(f32, D) }
8390 }
8391
8392 #[inline]
8393 unsafe fn decode(
8394 &mut self,
8395 decoder: &mut fidl::encoding::Decoder<'_, D>,
8396 offset: usize,
8397 _depth: fidl::encoding::Depth,
8398 ) -> fidl::Result<()> {
8399 decoder.debug_check_bounds::<Self>(offset);
8400 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
8402 Ok(())
8403 }
8404 }
8405
8406 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Response {
8407 type Borrowed<'a> = &'a Self;
8408 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8409 value
8410 }
8411 }
8412
8413 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Response {
8414 type Owned = Self;
8415
8416 #[inline(always)]
8417 fn inline_align(_context: fidl::encoding::Context) -> usize {
8418 4
8419 }
8420
8421 #[inline(always)]
8422 fn inline_size(_context: fidl::encoding::Context) -> usize {
8423 4
8424 }
8425 }
8426
8427 unsafe impl<D: fidl::encoding::ResourceDialect>
8428 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D>
8429 for &AudioCoreGetVolumeFromDb2Response
8430 {
8431 #[inline]
8432 unsafe fn encode(
8433 self,
8434 encoder: &mut fidl::encoding::Encoder<'_, D>,
8435 offset: usize,
8436 _depth: fidl::encoding::Depth,
8437 ) -> fidl::Result<()> {
8438 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8439 fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Response, D>::encode(
8441 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
8442 encoder,
8443 offset,
8444 _depth,
8445 )
8446 }
8447 }
8448 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8449 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D> for (T0,)
8450 {
8451 #[inline]
8452 unsafe fn encode(
8453 self,
8454 encoder: &mut fidl::encoding::Encoder<'_, D>,
8455 offset: usize,
8456 depth: fidl::encoding::Depth,
8457 ) -> fidl::Result<()> {
8458 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8459 self.0.encode(encoder, offset + 0, depth)?;
8463 Ok(())
8464 }
8465 }
8466
8467 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8468 for AudioCoreGetVolumeFromDb2Response
8469 {
8470 #[inline(always)]
8471 fn new_empty() -> Self {
8472 Self { volume: fidl::new_empty!(f32, D) }
8473 }
8474
8475 #[inline]
8476 unsafe fn decode(
8477 &mut self,
8478 decoder: &mut fidl::encoding::Decoder<'_, D>,
8479 offset: usize,
8480 _depth: fidl::encoding::Depth,
8481 ) -> fidl::Result<()> {
8482 decoder.debug_check_bounds::<Self>(offset);
8483 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
8485 Ok(())
8486 }
8487 }
8488
8489 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8490 type Borrowed<'a> = &'a Self;
8491 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8492 value
8493 }
8494 }
8495
8496 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8497 type Owned = Self;
8498
8499 #[inline(always)]
8500 fn inline_align(_context: fidl::encoding::Context) -> usize {
8501 8
8502 }
8503
8504 #[inline(always)]
8505 fn inline_size(_context: fidl::encoding::Context) -> usize {
8506 8
8507 }
8508 #[inline(always)]
8509 fn encode_is_copy() -> bool {
8510 true
8511 }
8512
8513 #[inline(always)]
8514 fn decode_is_copy() -> bool {
8515 true
8516 }
8517 }
8518
8519 unsafe impl<D: fidl::encoding::ResourceDialect>
8520 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D>
8521 for &AudioDeviceEnumeratorGetDeviceGainRequest
8522 {
8523 #[inline]
8524 unsafe fn encode(
8525 self,
8526 encoder: &mut fidl::encoding::Encoder<'_, D>,
8527 offset: usize,
8528 _depth: fidl::encoding::Depth,
8529 ) -> fidl::Result<()> {
8530 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8531 unsafe {
8532 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8534 (buf_ptr as *mut AudioDeviceEnumeratorGetDeviceGainRequest).write_unaligned(
8535 (self as *const AudioDeviceEnumeratorGetDeviceGainRequest).read(),
8536 );
8537 }
8540 Ok(())
8541 }
8542 }
8543 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
8544 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D> for (T0,)
8545 {
8546 #[inline]
8547 unsafe fn encode(
8548 self,
8549 encoder: &mut fidl::encoding::Encoder<'_, D>,
8550 offset: usize,
8551 depth: fidl::encoding::Depth,
8552 ) -> fidl::Result<()> {
8553 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8554 self.0.encode(encoder, offset + 0, depth)?;
8558 Ok(())
8559 }
8560 }
8561
8562 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8563 for AudioDeviceEnumeratorGetDeviceGainRequest
8564 {
8565 #[inline(always)]
8566 fn new_empty() -> Self {
8567 Self { device_token: fidl::new_empty!(u64, D) }
8568 }
8569
8570 #[inline]
8571 unsafe fn decode(
8572 &mut self,
8573 decoder: &mut fidl::encoding::Decoder<'_, D>,
8574 offset: usize,
8575 _depth: fidl::encoding::Depth,
8576 ) -> fidl::Result<()> {
8577 decoder.debug_check_bounds::<Self>(offset);
8578 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8579 unsafe {
8582 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
8583 }
8584 Ok(())
8585 }
8586 }
8587
8588 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8589 type Borrowed<'a> = &'a Self;
8590 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8591 value
8592 }
8593 }
8594
8595 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8596 type Owned = Self;
8597
8598 #[inline(always)]
8599 fn inline_align(_context: fidl::encoding::Context) -> usize {
8600 8
8601 }
8602
8603 #[inline(always)]
8604 fn inline_size(_context: fidl::encoding::Context) -> usize {
8605 16
8606 }
8607 }
8608
8609 unsafe impl<D: fidl::encoding::ResourceDialect>
8610 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D>
8611 for &AudioDeviceEnumeratorGetDeviceGainResponse
8612 {
8613 #[inline]
8614 unsafe fn encode(
8615 self,
8616 encoder: &mut fidl::encoding::Encoder<'_, D>,
8617 offset: usize,
8618 _depth: fidl::encoding::Depth,
8619 ) -> fidl::Result<()> {
8620 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8621 fidl::encoding::Encode::<AudioDeviceEnumeratorGetDeviceGainResponse, D>::encode(
8623 (
8624 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
8625 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
8626 ),
8627 encoder,
8628 offset,
8629 _depth,
8630 )
8631 }
8632 }
8633 unsafe impl<
8634 D: fidl::encoding::ResourceDialect,
8635 T0: fidl::encoding::Encode<u64, D>,
8636 T1: fidl::encoding::Encode<AudioGainInfo, D>,
8637 > fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D> for (T0, T1)
8638 {
8639 #[inline]
8640 unsafe fn encode(
8641 self,
8642 encoder: &mut fidl::encoding::Encoder<'_, D>,
8643 offset: usize,
8644 depth: fidl::encoding::Depth,
8645 ) -> fidl::Result<()> {
8646 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8647 self.0.encode(encoder, offset + 0, depth)?;
8651 self.1.encode(encoder, offset + 8, depth)?;
8652 Ok(())
8653 }
8654 }
8655
8656 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8657 for AudioDeviceEnumeratorGetDeviceGainResponse
8658 {
8659 #[inline(always)]
8660 fn new_empty() -> Self {
8661 Self {
8662 device_token: fidl::new_empty!(u64, D),
8663 gain_info: fidl::new_empty!(AudioGainInfo, D),
8664 }
8665 }
8666
8667 #[inline]
8668 unsafe fn decode(
8669 &mut self,
8670 decoder: &mut fidl::encoding::Decoder<'_, D>,
8671 offset: usize,
8672 _depth: fidl::encoding::Depth,
8673 ) -> fidl::Result<()> {
8674 decoder.debug_check_bounds::<Self>(offset);
8675 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
8677 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
8678 Ok(())
8679 }
8680 }
8681
8682 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDevicesResponse {
8683 type Borrowed<'a> = &'a Self;
8684 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8685 value
8686 }
8687 }
8688
8689 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDevicesResponse {
8690 type Owned = Self;
8691
8692 #[inline(always)]
8693 fn inline_align(_context: fidl::encoding::Context) -> usize {
8694 8
8695 }
8696
8697 #[inline(always)]
8698 fn inline_size(_context: fidl::encoding::Context) -> usize {
8699 16
8700 }
8701 }
8702
8703 unsafe impl<D: fidl::encoding::ResourceDialect>
8704 fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D>
8705 for &AudioDeviceEnumeratorGetDevicesResponse
8706 {
8707 #[inline]
8708 unsafe fn encode(
8709 self,
8710 encoder: &mut fidl::encoding::Encoder<'_, D>,
8711 offset: usize,
8712 _depth: fidl::encoding::Depth,
8713 ) -> fidl::Result<()> {
8714 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8715 fidl::encoding::Encode::<AudioDeviceEnumeratorGetDevicesResponse, D>::encode(
8717 (
8718 <fidl::encoding::UnboundedVector<AudioDeviceInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.devices),
8719 ),
8720 encoder, offset, _depth
8721 )
8722 }
8723 }
8724 unsafe impl<
8725 D: fidl::encoding::ResourceDialect,
8726 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<AudioDeviceInfo>, D>,
8727 > fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D> for (T0,)
8728 {
8729 #[inline]
8730 unsafe fn encode(
8731 self,
8732 encoder: &mut fidl::encoding::Encoder<'_, D>,
8733 offset: usize,
8734 depth: fidl::encoding::Depth,
8735 ) -> fidl::Result<()> {
8736 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8737 self.0.encode(encoder, offset + 0, depth)?;
8741 Ok(())
8742 }
8743 }
8744
8745 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8746 for AudioDeviceEnumeratorGetDevicesResponse
8747 {
8748 #[inline(always)]
8749 fn new_empty() -> Self {
8750 Self { devices: fidl::new_empty!(fidl::encoding::UnboundedVector<AudioDeviceInfo>, D) }
8751 }
8752
8753 #[inline]
8754 unsafe fn decode(
8755 &mut self,
8756 decoder: &mut fidl::encoding::Decoder<'_, D>,
8757 offset: usize,
8758 _depth: fidl::encoding::Depth,
8759 ) -> fidl::Result<()> {
8760 decoder.debug_check_bounds::<Self>(offset);
8761 fidl::decode!(
8763 fidl::encoding::UnboundedVector<AudioDeviceInfo>,
8764 D,
8765 &mut self.devices,
8766 decoder,
8767 offset + 0,
8768 _depth
8769 )?;
8770 Ok(())
8771 }
8772 }
8773
8774 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8775 type Borrowed<'a> = &'a Self;
8776 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8777 value
8778 }
8779 }
8780
8781 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8782 type Owned = Self;
8783
8784 #[inline(always)]
8785 fn inline_align(_context: fidl::encoding::Context) -> usize {
8786 8
8787 }
8788
8789 #[inline(always)]
8790 fn inline_size(_context: fidl::encoding::Context) -> usize {
8791 16
8792 }
8793 #[inline(always)]
8794 fn encode_is_copy() -> bool {
8795 true
8796 }
8797
8798 #[inline(always)]
8799 fn decode_is_copy() -> bool {
8800 true
8801 }
8802 }
8803
8804 unsafe impl<D: fidl::encoding::ResourceDialect>
8805 fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8806 for &AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8807 {
8808 #[inline]
8809 unsafe fn encode(
8810 self,
8811 encoder: &mut fidl::encoding::Encoder<'_, D>,
8812 offset: usize,
8813 _depth: fidl::encoding::Depth,
8814 ) -> fidl::Result<()> {
8815 encoder
8816 .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8817 unsafe {
8818 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8820 (buf_ptr as *mut AudioDeviceEnumeratorOnDefaultDeviceChangedRequest)
8821 .write_unaligned(
8822 (self as *const AudioDeviceEnumeratorOnDefaultDeviceChangedRequest).read(),
8823 );
8824 }
8827 Ok(())
8828 }
8829 }
8830 unsafe impl<
8831 D: fidl::encoding::ResourceDialect,
8832 T0: fidl::encoding::Encode<u64, D>,
8833 T1: fidl::encoding::Encode<u64, D>,
8834 > fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8835 for (T0, T1)
8836 {
8837 #[inline]
8838 unsafe fn encode(
8839 self,
8840 encoder: &mut fidl::encoding::Encoder<'_, D>,
8841 offset: usize,
8842 depth: fidl::encoding::Depth,
8843 ) -> fidl::Result<()> {
8844 encoder
8845 .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8846 self.0.encode(encoder, offset + 0, depth)?;
8850 self.1.encode(encoder, offset + 8, depth)?;
8851 Ok(())
8852 }
8853 }
8854
8855 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8856 for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8857 {
8858 #[inline(always)]
8859 fn new_empty() -> Self {
8860 Self {
8861 old_default_token: fidl::new_empty!(u64, D),
8862 new_default_token: fidl::new_empty!(u64, D),
8863 }
8864 }
8865
8866 #[inline]
8867 unsafe fn decode(
8868 &mut self,
8869 decoder: &mut fidl::encoding::Decoder<'_, D>,
8870 offset: usize,
8871 _depth: fidl::encoding::Depth,
8872 ) -> fidl::Result<()> {
8873 decoder.debug_check_bounds::<Self>(offset);
8874 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8875 unsafe {
8878 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
8879 }
8880 Ok(())
8881 }
8882 }
8883
8884 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8885 type Borrowed<'a> = &'a Self;
8886 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8887 value
8888 }
8889 }
8890
8891 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8892 type Owned = Self;
8893
8894 #[inline(always)]
8895 fn inline_align(_context: fidl::encoding::Context) -> usize {
8896 8
8897 }
8898
8899 #[inline(always)]
8900 fn inline_size(_context: fidl::encoding::Context) -> usize {
8901 56
8902 }
8903 }
8904
8905 unsafe impl<D: fidl::encoding::ResourceDialect>
8906 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D>
8907 for &AudioDeviceEnumeratorOnDeviceAddedRequest
8908 {
8909 #[inline]
8910 unsafe fn encode(
8911 self,
8912 encoder: &mut fidl::encoding::Encoder<'_, D>,
8913 offset: usize,
8914 _depth: fidl::encoding::Depth,
8915 ) -> fidl::Result<()> {
8916 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8917 fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceAddedRequest, D>::encode(
8919 (<AudioDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
8920 encoder,
8921 offset,
8922 _depth,
8923 )
8924 }
8925 }
8926 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioDeviceInfo, D>>
8927 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D> for (T0,)
8928 {
8929 #[inline]
8930 unsafe fn encode(
8931 self,
8932 encoder: &mut fidl::encoding::Encoder<'_, D>,
8933 offset: usize,
8934 depth: fidl::encoding::Depth,
8935 ) -> fidl::Result<()> {
8936 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8937 self.0.encode(encoder, offset + 0, depth)?;
8941 Ok(())
8942 }
8943 }
8944
8945 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8946 for AudioDeviceEnumeratorOnDeviceAddedRequest
8947 {
8948 #[inline(always)]
8949 fn new_empty() -> Self {
8950 Self { device: fidl::new_empty!(AudioDeviceInfo, D) }
8951 }
8952
8953 #[inline]
8954 unsafe fn decode(
8955 &mut self,
8956 decoder: &mut fidl::encoding::Decoder<'_, D>,
8957 offset: usize,
8958 _depth: fidl::encoding::Depth,
8959 ) -> fidl::Result<()> {
8960 decoder.debug_check_bounds::<Self>(offset);
8961 fidl::decode!(AudioDeviceInfo, D, &mut self.device, decoder, offset + 0, _depth)?;
8963 Ok(())
8964 }
8965 }
8966
8967 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceGainChangedRequest {
8968 type Borrowed<'a> = &'a Self;
8969 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8970 value
8971 }
8972 }
8973
8974 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceGainChangedRequest {
8975 type Owned = Self;
8976
8977 #[inline(always)]
8978 fn inline_align(_context: fidl::encoding::Context) -> usize {
8979 8
8980 }
8981
8982 #[inline(always)]
8983 fn inline_size(_context: fidl::encoding::Context) -> usize {
8984 16
8985 }
8986 }
8987
8988 unsafe impl<D: fidl::encoding::ResourceDialect>
8989 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>
8990 for &AudioDeviceEnumeratorOnDeviceGainChangedRequest
8991 {
8992 #[inline]
8993 unsafe fn encode(
8994 self,
8995 encoder: &mut fidl::encoding::Encoder<'_, D>,
8996 offset: usize,
8997 _depth: fidl::encoding::Depth,
8998 ) -> fidl::Result<()> {
8999 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
9000 fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>::encode(
9002 (
9003 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
9004 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9005 ),
9006 encoder,
9007 offset,
9008 _depth,
9009 )
9010 }
9011 }
9012 unsafe impl<
9013 D: fidl::encoding::ResourceDialect,
9014 T0: fidl::encoding::Encode<u64, D>,
9015 T1: fidl::encoding::Encode<AudioGainInfo, D>,
9016 > fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D> for (T0, T1)
9017 {
9018 #[inline]
9019 unsafe fn encode(
9020 self,
9021 encoder: &mut fidl::encoding::Encoder<'_, D>,
9022 offset: usize,
9023 depth: fidl::encoding::Depth,
9024 ) -> fidl::Result<()> {
9025 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
9026 self.0.encode(encoder, offset + 0, depth)?;
9030 self.1.encode(encoder, offset + 8, depth)?;
9031 Ok(())
9032 }
9033 }
9034
9035 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9036 for AudioDeviceEnumeratorOnDeviceGainChangedRequest
9037 {
9038 #[inline(always)]
9039 fn new_empty() -> Self {
9040 Self {
9041 device_token: fidl::new_empty!(u64, D),
9042 gain_info: fidl::new_empty!(AudioGainInfo, D),
9043 }
9044 }
9045
9046 #[inline]
9047 unsafe fn decode(
9048 &mut self,
9049 decoder: &mut fidl::encoding::Decoder<'_, D>,
9050 offset: usize,
9051 _depth: fidl::encoding::Depth,
9052 ) -> fidl::Result<()> {
9053 decoder.debug_check_bounds::<Self>(offset);
9054 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
9056 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
9057 Ok(())
9058 }
9059 }
9060
9061 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
9062 type Borrowed<'a> = &'a Self;
9063 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9064 value
9065 }
9066 }
9067
9068 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
9069 type Owned = Self;
9070
9071 #[inline(always)]
9072 fn inline_align(_context: fidl::encoding::Context) -> usize {
9073 8
9074 }
9075
9076 #[inline(always)]
9077 fn inline_size(_context: fidl::encoding::Context) -> usize {
9078 8
9079 }
9080 #[inline(always)]
9081 fn encode_is_copy() -> bool {
9082 true
9083 }
9084
9085 #[inline(always)]
9086 fn decode_is_copy() -> bool {
9087 true
9088 }
9089 }
9090
9091 unsafe impl<D: fidl::encoding::ResourceDialect>
9092 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D>
9093 for &AudioDeviceEnumeratorOnDeviceRemovedRequest
9094 {
9095 #[inline]
9096 unsafe fn encode(
9097 self,
9098 encoder: &mut fidl::encoding::Encoder<'_, D>,
9099 offset: usize,
9100 _depth: fidl::encoding::Depth,
9101 ) -> fidl::Result<()> {
9102 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
9103 unsafe {
9104 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9106 (buf_ptr as *mut AudioDeviceEnumeratorOnDeviceRemovedRequest).write_unaligned(
9107 (self as *const AudioDeviceEnumeratorOnDeviceRemovedRequest).read(),
9108 );
9109 }
9112 Ok(())
9113 }
9114 }
9115 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
9116 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D> for (T0,)
9117 {
9118 #[inline]
9119 unsafe fn encode(
9120 self,
9121 encoder: &mut fidl::encoding::Encoder<'_, D>,
9122 offset: usize,
9123 depth: fidl::encoding::Depth,
9124 ) -> fidl::Result<()> {
9125 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
9126 self.0.encode(encoder, offset + 0, depth)?;
9130 Ok(())
9131 }
9132 }
9133
9134 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9135 for AudioDeviceEnumeratorOnDeviceRemovedRequest
9136 {
9137 #[inline(always)]
9138 fn new_empty() -> Self {
9139 Self { device_token: fidl::new_empty!(u64, D) }
9140 }
9141
9142 #[inline]
9143 unsafe fn decode(
9144 &mut self,
9145 decoder: &mut fidl::encoding::Decoder<'_, D>,
9146 offset: usize,
9147 _depth: fidl::encoding::Depth,
9148 ) -> fidl::Result<()> {
9149 decoder.debug_check_bounds::<Self>(offset);
9150 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9151 unsafe {
9154 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9155 }
9156 Ok(())
9157 }
9158 }
9159
9160 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorSetDeviceGainRequest {
9161 type Borrowed<'a> = &'a Self;
9162 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9163 value
9164 }
9165 }
9166
9167 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorSetDeviceGainRequest {
9168 type Owned = Self;
9169
9170 #[inline(always)]
9171 fn inline_align(_context: fidl::encoding::Context) -> usize {
9172 8
9173 }
9174
9175 #[inline(always)]
9176 fn inline_size(_context: fidl::encoding::Context) -> usize {
9177 24
9178 }
9179 }
9180
9181 unsafe impl<D: fidl::encoding::ResourceDialect>
9182 fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D>
9183 for &AudioDeviceEnumeratorSetDeviceGainRequest
9184 {
9185 #[inline]
9186 unsafe fn encode(
9187 self,
9188 encoder: &mut fidl::encoding::Encoder<'_, D>,
9189 offset: usize,
9190 _depth: fidl::encoding::Depth,
9191 ) -> fidl::Result<()> {
9192 encoder.debug_check_bounds::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9193 fidl::encoding::Encode::<AudioDeviceEnumeratorSetDeviceGainRequest, D>::encode(
9195 (
9196 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
9197 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9198 <AudioGainValidFlags as fidl::encoding::ValueTypeMarker>::borrow(
9199 &self.valid_flags,
9200 ),
9201 ),
9202 encoder,
9203 offset,
9204 _depth,
9205 )
9206 }
9207 }
9208 unsafe impl<
9209 D: fidl::encoding::ResourceDialect,
9210 T0: fidl::encoding::Encode<u64, D>,
9211 T1: fidl::encoding::Encode<AudioGainInfo, D>,
9212 T2: fidl::encoding::Encode<AudioGainValidFlags, D>,
9213 > fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D> for (T0, T1, T2)
9214 {
9215 #[inline]
9216 unsafe fn encode(
9217 self,
9218 encoder: &mut fidl::encoding::Encoder<'_, D>,
9219 offset: usize,
9220 depth: fidl::encoding::Depth,
9221 ) -> fidl::Result<()> {
9222 encoder.debug_check_bounds::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9223 unsafe {
9226 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
9227 (ptr as *mut u64).write_unaligned(0);
9228 }
9229 self.0.encode(encoder, offset + 0, depth)?;
9231 self.1.encode(encoder, offset + 8, depth)?;
9232 self.2.encode(encoder, offset + 16, depth)?;
9233 Ok(())
9234 }
9235 }
9236
9237 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9238 for AudioDeviceEnumeratorSetDeviceGainRequest
9239 {
9240 #[inline(always)]
9241 fn new_empty() -> Self {
9242 Self {
9243 device_token: fidl::new_empty!(u64, D),
9244 gain_info: fidl::new_empty!(AudioGainInfo, D),
9245 valid_flags: fidl::new_empty!(AudioGainValidFlags, D),
9246 }
9247 }
9248
9249 #[inline]
9250 unsafe fn decode(
9251 &mut self,
9252 decoder: &mut fidl::encoding::Decoder<'_, D>,
9253 offset: usize,
9254 _depth: fidl::encoding::Depth,
9255 ) -> fidl::Result<()> {
9256 decoder.debug_check_bounds::<Self>(offset);
9257 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
9259 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9260 let mask = 0xffffffff00000000u64;
9261 let maskedval = padval & mask;
9262 if maskedval != 0 {
9263 return Err(fidl::Error::NonZeroPadding {
9264 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
9265 });
9266 }
9267 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
9268 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
9269 fidl::decode!(
9270 AudioGainValidFlags,
9271 D,
9272 &mut self.valid_flags,
9273 decoder,
9274 offset + 16,
9275 _depth
9276 )?;
9277 Ok(())
9278 }
9279 }
9280
9281 impl fidl::encoding::ValueTypeMarker for AudioDeviceInfo {
9282 type Borrowed<'a> = &'a Self;
9283 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9284 value
9285 }
9286 }
9287
9288 unsafe impl fidl::encoding::TypeMarker for AudioDeviceInfo {
9289 type Owned = Self;
9290
9291 #[inline(always)]
9292 fn inline_align(_context: fidl::encoding::Context) -> usize {
9293 8
9294 }
9295
9296 #[inline(always)]
9297 fn inline_size(_context: fidl::encoding::Context) -> usize {
9298 56
9299 }
9300 }
9301
9302 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioDeviceInfo, D>
9303 for &AudioDeviceInfo
9304 {
9305 #[inline]
9306 unsafe fn encode(
9307 self,
9308 encoder: &mut fidl::encoding::Encoder<'_, D>,
9309 offset: usize,
9310 _depth: fidl::encoding::Depth,
9311 ) -> fidl::Result<()> {
9312 encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9313 fidl::encoding::Encode::<AudioDeviceInfo, D>::encode(
9315 (
9316 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9317 &self.name,
9318 ),
9319 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9320 &self.unique_id,
9321 ),
9322 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.token_id),
9323 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_input),
9324 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9325 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_default),
9326 ),
9327 encoder,
9328 offset,
9329 _depth,
9330 )
9331 }
9332 }
9333 unsafe impl<
9334 D: fidl::encoding::ResourceDialect,
9335 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9336 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9337 T2: fidl::encoding::Encode<u64, D>,
9338 T3: fidl::encoding::Encode<bool, D>,
9339 T4: fidl::encoding::Encode<AudioGainInfo, D>,
9340 T5: fidl::encoding::Encode<bool, D>,
9341 > fidl::encoding::Encode<AudioDeviceInfo, D> for (T0, T1, T2, T3, T4, T5)
9342 {
9343 #[inline]
9344 unsafe fn encode(
9345 self,
9346 encoder: &mut fidl::encoding::Encoder<'_, D>,
9347 offset: usize,
9348 depth: fidl::encoding::Depth,
9349 ) -> fidl::Result<()> {
9350 encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9351 unsafe {
9354 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
9355 (ptr as *mut u64).write_unaligned(0);
9356 }
9357 unsafe {
9358 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
9359 (ptr as *mut u64).write_unaligned(0);
9360 }
9361 self.0.encode(encoder, offset + 0, depth)?;
9363 self.1.encode(encoder, offset + 16, depth)?;
9364 self.2.encode(encoder, offset + 32, depth)?;
9365 self.3.encode(encoder, offset + 40, depth)?;
9366 self.4.encode(encoder, offset + 44, depth)?;
9367 self.5.encode(encoder, offset + 52, depth)?;
9368 Ok(())
9369 }
9370 }
9371
9372 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioDeviceInfo {
9373 #[inline(always)]
9374 fn new_empty() -> Self {
9375 Self {
9376 name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9377 unique_id: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9378 token_id: fidl::new_empty!(u64, D),
9379 is_input: fidl::new_empty!(bool, D),
9380 gain_info: fidl::new_empty!(AudioGainInfo, D),
9381 is_default: fidl::new_empty!(bool, D),
9382 }
9383 }
9384
9385 #[inline]
9386 unsafe fn decode(
9387 &mut self,
9388 decoder: &mut fidl::encoding::Decoder<'_, D>,
9389 offset: usize,
9390 _depth: fidl::encoding::Depth,
9391 ) -> fidl::Result<()> {
9392 decoder.debug_check_bounds::<Self>(offset);
9393 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
9395 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9396 let mask = 0xffffff00u64;
9397 let maskedval = padval & mask;
9398 if maskedval != 0 {
9399 return Err(fidl::Error::NonZeroPadding {
9400 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
9401 });
9402 }
9403 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
9404 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9405 let mask = 0xffffff0000000000u64;
9406 let maskedval = padval & mask;
9407 if maskedval != 0 {
9408 return Err(fidl::Error::NonZeroPadding {
9409 padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
9410 });
9411 }
9412 fidl::decode!(
9413 fidl::encoding::UnboundedString,
9414 D,
9415 &mut self.name,
9416 decoder,
9417 offset + 0,
9418 _depth
9419 )?;
9420 fidl::decode!(
9421 fidl::encoding::UnboundedString,
9422 D,
9423 &mut self.unique_id,
9424 decoder,
9425 offset + 16,
9426 _depth
9427 )?;
9428 fidl::decode!(u64, D, &mut self.token_id, decoder, offset + 32, _depth)?;
9429 fidl::decode!(bool, D, &mut self.is_input, decoder, offset + 40, _depth)?;
9430 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 44, _depth)?;
9431 fidl::decode!(bool, D, &mut self.is_default, decoder, offset + 52, _depth)?;
9432 Ok(())
9433 }
9434 }
9435
9436 impl fidl::encoding::ValueTypeMarker for AudioGainInfo {
9437 type Borrowed<'a> = &'a Self;
9438 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9439 value
9440 }
9441 }
9442
9443 unsafe impl fidl::encoding::TypeMarker for AudioGainInfo {
9444 type Owned = Self;
9445
9446 #[inline(always)]
9447 fn inline_align(_context: fidl::encoding::Context) -> usize {
9448 4
9449 }
9450
9451 #[inline(always)]
9452 fn inline_size(_context: fidl::encoding::Context) -> usize {
9453 8
9454 }
9455 }
9456
9457 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioGainInfo, D>
9458 for &AudioGainInfo
9459 {
9460 #[inline]
9461 unsafe fn encode(
9462 self,
9463 encoder: &mut fidl::encoding::Encoder<'_, D>,
9464 offset: usize,
9465 _depth: fidl::encoding::Depth,
9466 ) -> fidl::Result<()> {
9467 encoder.debug_check_bounds::<AudioGainInfo>(offset);
9468 fidl::encoding::Encode::<AudioGainInfo, D>::encode(
9470 (
9471 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
9472 <AudioGainInfoFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
9473 ),
9474 encoder,
9475 offset,
9476 _depth,
9477 )
9478 }
9479 }
9480 unsafe impl<
9481 D: fidl::encoding::ResourceDialect,
9482 T0: fidl::encoding::Encode<f32, D>,
9483 T1: fidl::encoding::Encode<AudioGainInfoFlags, D>,
9484 > fidl::encoding::Encode<AudioGainInfo, D> for (T0, T1)
9485 {
9486 #[inline]
9487 unsafe fn encode(
9488 self,
9489 encoder: &mut fidl::encoding::Encoder<'_, D>,
9490 offset: usize,
9491 depth: fidl::encoding::Depth,
9492 ) -> fidl::Result<()> {
9493 encoder.debug_check_bounds::<AudioGainInfo>(offset);
9494 self.0.encode(encoder, offset + 0, depth)?;
9498 self.1.encode(encoder, offset + 4, depth)?;
9499 Ok(())
9500 }
9501 }
9502
9503 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfo {
9504 #[inline(always)]
9505 fn new_empty() -> Self {
9506 Self {
9507 gain_db: fidl::new_empty!(f32, D),
9508 flags: fidl::new_empty!(AudioGainInfoFlags, D),
9509 }
9510 }
9511
9512 #[inline]
9513 unsafe fn decode(
9514 &mut self,
9515 decoder: &mut fidl::encoding::Decoder<'_, D>,
9516 offset: usize,
9517 _depth: fidl::encoding::Depth,
9518 ) -> fidl::Result<()> {
9519 decoder.debug_check_bounds::<Self>(offset);
9520 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
9522 fidl::decode!(AudioGainInfoFlags, D, &mut self.flags, decoder, offset + 4, _depth)?;
9523 Ok(())
9524 }
9525 }
9526
9527 impl fidl::encoding::ValueTypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9528 type Borrowed<'a> = &'a Self;
9529 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9530 value
9531 }
9532 }
9533
9534 unsafe impl fidl::encoding::TypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9535 type Owned = Self;
9536
9537 #[inline(always)]
9538 fn inline_align(_context: fidl::encoding::Context) -> usize {
9539 1
9540 }
9541
9542 #[inline(always)]
9543 fn inline_size(_context: fidl::encoding::Context) -> usize {
9544 1
9545 }
9546 }
9547
9548 unsafe impl<D: fidl::encoding::ResourceDialect>
9549 fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D>
9550 for &AudioRendererEnableMinLeadTimeEventsRequest
9551 {
9552 #[inline]
9553 unsafe fn encode(
9554 self,
9555 encoder: &mut fidl::encoding::Encoder<'_, D>,
9556 offset: usize,
9557 _depth: fidl::encoding::Depth,
9558 ) -> fidl::Result<()> {
9559 encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9560 fidl::encoding::Encode::<AudioRendererEnableMinLeadTimeEventsRequest, D>::encode(
9562 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
9563 encoder,
9564 offset,
9565 _depth,
9566 )
9567 }
9568 }
9569 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
9570 fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D> for (T0,)
9571 {
9572 #[inline]
9573 unsafe fn encode(
9574 self,
9575 encoder: &mut fidl::encoding::Encoder<'_, D>,
9576 offset: usize,
9577 depth: fidl::encoding::Depth,
9578 ) -> fidl::Result<()> {
9579 encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9580 self.0.encode(encoder, offset + 0, depth)?;
9584 Ok(())
9585 }
9586 }
9587
9588 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9589 for AudioRendererEnableMinLeadTimeEventsRequest
9590 {
9591 #[inline(always)]
9592 fn new_empty() -> Self {
9593 Self { enabled: fidl::new_empty!(bool, D) }
9594 }
9595
9596 #[inline]
9597 unsafe fn decode(
9598 &mut self,
9599 decoder: &mut fidl::encoding::Decoder<'_, D>,
9600 offset: usize,
9601 _depth: fidl::encoding::Depth,
9602 ) -> fidl::Result<()> {
9603 decoder.debug_check_bounds::<Self>(offset);
9604 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
9606 Ok(())
9607 }
9608 }
9609
9610 impl fidl::encoding::ValueTypeMarker for AudioRendererGetMinLeadTimeResponse {
9611 type Borrowed<'a> = &'a Self;
9612 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9613 value
9614 }
9615 }
9616
9617 unsafe impl fidl::encoding::TypeMarker for AudioRendererGetMinLeadTimeResponse {
9618 type Owned = Self;
9619
9620 #[inline(always)]
9621 fn inline_align(_context: fidl::encoding::Context) -> usize {
9622 8
9623 }
9624
9625 #[inline(always)]
9626 fn inline_size(_context: fidl::encoding::Context) -> usize {
9627 8
9628 }
9629 #[inline(always)]
9630 fn encode_is_copy() -> bool {
9631 true
9632 }
9633
9634 #[inline(always)]
9635 fn decode_is_copy() -> bool {
9636 true
9637 }
9638 }
9639
9640 unsafe impl<D: fidl::encoding::ResourceDialect>
9641 fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D>
9642 for &AudioRendererGetMinLeadTimeResponse
9643 {
9644 #[inline]
9645 unsafe fn encode(
9646 self,
9647 encoder: &mut fidl::encoding::Encoder<'_, D>,
9648 offset: usize,
9649 _depth: fidl::encoding::Depth,
9650 ) -> fidl::Result<()> {
9651 encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9652 unsafe {
9653 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9655 (buf_ptr as *mut AudioRendererGetMinLeadTimeResponse)
9656 .write_unaligned((self as *const AudioRendererGetMinLeadTimeResponse).read());
9657 }
9660 Ok(())
9661 }
9662 }
9663 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9664 fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D> for (T0,)
9665 {
9666 #[inline]
9667 unsafe fn encode(
9668 self,
9669 encoder: &mut fidl::encoding::Encoder<'_, D>,
9670 offset: usize,
9671 depth: fidl::encoding::Depth,
9672 ) -> fidl::Result<()> {
9673 encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9674 self.0.encode(encoder, offset + 0, depth)?;
9678 Ok(())
9679 }
9680 }
9681
9682 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9683 for AudioRendererGetMinLeadTimeResponse
9684 {
9685 #[inline(always)]
9686 fn new_empty() -> Self {
9687 Self { min_lead_time_nsec: fidl::new_empty!(i64, D) }
9688 }
9689
9690 #[inline]
9691 unsafe fn decode(
9692 &mut self,
9693 decoder: &mut fidl::encoding::Decoder<'_, D>,
9694 offset: usize,
9695 _depth: fidl::encoding::Depth,
9696 ) -> fidl::Result<()> {
9697 decoder.debug_check_bounds::<Self>(offset);
9698 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9699 unsafe {
9702 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9703 }
9704 Ok(())
9705 }
9706 }
9707
9708 impl fidl::encoding::ValueTypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9709 type Borrowed<'a> = &'a Self;
9710 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9711 value
9712 }
9713 }
9714
9715 unsafe impl fidl::encoding::TypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9716 type Owned = Self;
9717
9718 #[inline(always)]
9719 fn inline_align(_context: fidl::encoding::Context) -> usize {
9720 8
9721 }
9722
9723 #[inline(always)]
9724 fn inline_size(_context: fidl::encoding::Context) -> usize {
9725 8
9726 }
9727 #[inline(always)]
9728 fn encode_is_copy() -> bool {
9729 true
9730 }
9731
9732 #[inline(always)]
9733 fn decode_is_copy() -> bool {
9734 true
9735 }
9736 }
9737
9738 unsafe impl<D: fidl::encoding::ResourceDialect>
9739 fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, D>
9740 for &AudioRendererOnMinLeadTimeChangedRequest
9741 {
9742 #[inline]
9743 unsafe fn encode(
9744 self,
9745 encoder: &mut fidl::encoding::Encoder<'_, D>,
9746 offset: usize,
9747 _depth: fidl::encoding::Depth,
9748 ) -> fidl::Result<()> {
9749 encoder.debug_check_bounds::<AudioRendererOnMinLeadTimeChangedRequest>(offset);
9750 unsafe {
9751 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9753 (buf_ptr as *mut AudioRendererOnMinLeadTimeChangedRequest).write_unaligned(
9754 (self as *const AudioRendererOnMinLeadTimeChangedRequest).read(),
9755 );
9756 }
9759 Ok(())
9760 }
9761 }
9762 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9763 fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, D> for (T0,)
9764 {
9765 #[inline]
9766 unsafe fn encode(
9767 self,
9768 encoder: &mut fidl::encoding::Encoder<'_, D>,
9769 offset: usize,
9770 depth: fidl::encoding::Depth,
9771 ) -> fidl::Result<()> {
9772 encoder.debug_check_bounds::<AudioRendererOnMinLeadTimeChangedRequest>(offset);
9773 self.0.encode(encoder, offset + 0, depth)?;
9777 Ok(())
9778 }
9779 }
9780
9781 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9782 for AudioRendererOnMinLeadTimeChangedRequest
9783 {
9784 #[inline(always)]
9785 fn new_empty() -> Self {
9786 Self { min_lead_time_nsec: fidl::new_empty!(i64, D) }
9787 }
9788
9789 #[inline]
9790 unsafe fn decode(
9791 &mut self,
9792 decoder: &mut fidl::encoding::Decoder<'_, D>,
9793 offset: usize,
9794 _depth: fidl::encoding::Depth,
9795 ) -> fidl::Result<()> {
9796 decoder.debug_check_bounds::<Self>(offset);
9797 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9798 unsafe {
9801 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9802 }
9803 Ok(())
9804 }
9805 }
9806
9807 impl fidl::encoding::ValueTypeMarker for AudioRendererPauseResponse {
9808 type Borrowed<'a> = &'a Self;
9809 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9810 value
9811 }
9812 }
9813
9814 unsafe impl fidl::encoding::TypeMarker for AudioRendererPauseResponse {
9815 type Owned = Self;
9816
9817 #[inline(always)]
9818 fn inline_align(_context: fidl::encoding::Context) -> usize {
9819 8
9820 }
9821
9822 #[inline(always)]
9823 fn inline_size(_context: fidl::encoding::Context) -> usize {
9824 16
9825 }
9826 #[inline(always)]
9827 fn encode_is_copy() -> bool {
9828 true
9829 }
9830
9831 #[inline(always)]
9832 fn decode_is_copy() -> bool {
9833 true
9834 }
9835 }
9836
9837 unsafe impl<D: fidl::encoding::ResourceDialect>
9838 fidl::encoding::Encode<AudioRendererPauseResponse, D> for &AudioRendererPauseResponse
9839 {
9840 #[inline]
9841 unsafe fn encode(
9842 self,
9843 encoder: &mut fidl::encoding::Encoder<'_, D>,
9844 offset: usize,
9845 _depth: fidl::encoding::Depth,
9846 ) -> fidl::Result<()> {
9847 encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9848 unsafe {
9849 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9851 (buf_ptr as *mut AudioRendererPauseResponse)
9852 .write_unaligned((self as *const AudioRendererPauseResponse).read());
9853 }
9856 Ok(())
9857 }
9858 }
9859 unsafe impl<
9860 D: fidl::encoding::ResourceDialect,
9861 T0: fidl::encoding::Encode<i64, D>,
9862 T1: fidl::encoding::Encode<i64, D>,
9863 > fidl::encoding::Encode<AudioRendererPauseResponse, D> for (T0, T1)
9864 {
9865 #[inline]
9866 unsafe fn encode(
9867 self,
9868 encoder: &mut fidl::encoding::Encoder<'_, D>,
9869 offset: usize,
9870 depth: fidl::encoding::Depth,
9871 ) -> fidl::Result<()> {
9872 encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9873 self.0.encode(encoder, offset + 0, depth)?;
9877 self.1.encode(encoder, offset + 8, depth)?;
9878 Ok(())
9879 }
9880 }
9881
9882 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9883 for AudioRendererPauseResponse
9884 {
9885 #[inline(always)]
9886 fn new_empty() -> Self {
9887 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9888 }
9889
9890 #[inline]
9891 unsafe fn decode(
9892 &mut self,
9893 decoder: &mut fidl::encoding::Decoder<'_, D>,
9894 offset: usize,
9895 _depth: fidl::encoding::Depth,
9896 ) -> fidl::Result<()> {
9897 decoder.debug_check_bounds::<Self>(offset);
9898 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9899 unsafe {
9902 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
9903 }
9904 Ok(())
9905 }
9906 }
9907
9908 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayNoReplyRequest {
9909 type Borrowed<'a> = &'a Self;
9910 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9911 value
9912 }
9913 }
9914
9915 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayNoReplyRequest {
9916 type Owned = Self;
9917
9918 #[inline(always)]
9919 fn inline_align(_context: fidl::encoding::Context) -> usize {
9920 8
9921 }
9922
9923 #[inline(always)]
9924 fn inline_size(_context: fidl::encoding::Context) -> usize {
9925 16
9926 }
9927 #[inline(always)]
9928 fn encode_is_copy() -> bool {
9929 true
9930 }
9931
9932 #[inline(always)]
9933 fn decode_is_copy() -> bool {
9934 true
9935 }
9936 }
9937
9938 unsafe impl<D: fidl::encoding::ResourceDialect>
9939 fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D>
9940 for &AudioRendererPlayNoReplyRequest
9941 {
9942 #[inline]
9943 unsafe fn encode(
9944 self,
9945 encoder: &mut fidl::encoding::Encoder<'_, D>,
9946 offset: usize,
9947 _depth: fidl::encoding::Depth,
9948 ) -> fidl::Result<()> {
9949 encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9950 unsafe {
9951 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9953 (buf_ptr as *mut AudioRendererPlayNoReplyRequest)
9954 .write_unaligned((self as *const AudioRendererPlayNoReplyRequest).read());
9955 }
9958 Ok(())
9959 }
9960 }
9961 unsafe impl<
9962 D: fidl::encoding::ResourceDialect,
9963 T0: fidl::encoding::Encode<i64, D>,
9964 T1: fidl::encoding::Encode<i64, D>,
9965 > fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D> for (T0, T1)
9966 {
9967 #[inline]
9968 unsafe fn encode(
9969 self,
9970 encoder: &mut fidl::encoding::Encoder<'_, D>,
9971 offset: usize,
9972 depth: fidl::encoding::Depth,
9973 ) -> fidl::Result<()> {
9974 encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9975 self.0.encode(encoder, offset + 0, depth)?;
9979 self.1.encode(encoder, offset + 8, depth)?;
9980 Ok(())
9981 }
9982 }
9983
9984 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9985 for AudioRendererPlayNoReplyRequest
9986 {
9987 #[inline(always)]
9988 fn new_empty() -> Self {
9989 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9990 }
9991
9992 #[inline]
9993 unsafe fn decode(
9994 &mut self,
9995 decoder: &mut fidl::encoding::Decoder<'_, D>,
9996 offset: usize,
9997 _depth: fidl::encoding::Depth,
9998 ) -> fidl::Result<()> {
9999 decoder.debug_check_bounds::<Self>(offset);
10000 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10001 unsafe {
10004 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10005 }
10006 Ok(())
10007 }
10008 }
10009
10010 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayRequest {
10011 type Borrowed<'a> = &'a Self;
10012 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10013 value
10014 }
10015 }
10016
10017 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayRequest {
10018 type Owned = Self;
10019
10020 #[inline(always)]
10021 fn inline_align(_context: fidl::encoding::Context) -> usize {
10022 8
10023 }
10024
10025 #[inline(always)]
10026 fn inline_size(_context: fidl::encoding::Context) -> usize {
10027 16
10028 }
10029 #[inline(always)]
10030 fn encode_is_copy() -> bool {
10031 true
10032 }
10033
10034 #[inline(always)]
10035 fn decode_is_copy() -> bool {
10036 true
10037 }
10038 }
10039
10040 unsafe impl<D: fidl::encoding::ResourceDialect>
10041 fidl::encoding::Encode<AudioRendererPlayRequest, D> for &AudioRendererPlayRequest
10042 {
10043 #[inline]
10044 unsafe fn encode(
10045 self,
10046 encoder: &mut fidl::encoding::Encoder<'_, D>,
10047 offset: usize,
10048 _depth: fidl::encoding::Depth,
10049 ) -> fidl::Result<()> {
10050 encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
10051 unsafe {
10052 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10054 (buf_ptr as *mut AudioRendererPlayRequest)
10055 .write_unaligned((self as *const AudioRendererPlayRequest).read());
10056 }
10059 Ok(())
10060 }
10061 }
10062 unsafe impl<
10063 D: fidl::encoding::ResourceDialect,
10064 T0: fidl::encoding::Encode<i64, D>,
10065 T1: fidl::encoding::Encode<i64, D>,
10066 > fidl::encoding::Encode<AudioRendererPlayRequest, D> for (T0, T1)
10067 {
10068 #[inline]
10069 unsafe fn encode(
10070 self,
10071 encoder: &mut fidl::encoding::Encoder<'_, D>,
10072 offset: usize,
10073 depth: fidl::encoding::Depth,
10074 ) -> fidl::Result<()> {
10075 encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
10076 self.0.encode(encoder, offset + 0, depth)?;
10080 self.1.encode(encoder, offset + 8, depth)?;
10081 Ok(())
10082 }
10083 }
10084
10085 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10086 for AudioRendererPlayRequest
10087 {
10088 #[inline(always)]
10089 fn new_empty() -> Self {
10090 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
10091 }
10092
10093 #[inline]
10094 unsafe fn decode(
10095 &mut self,
10096 decoder: &mut fidl::encoding::Decoder<'_, D>,
10097 offset: usize,
10098 _depth: fidl::encoding::Depth,
10099 ) -> fidl::Result<()> {
10100 decoder.debug_check_bounds::<Self>(offset);
10101 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10102 unsafe {
10105 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10106 }
10107 Ok(())
10108 }
10109 }
10110
10111 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayResponse {
10112 type Borrowed<'a> = &'a Self;
10113 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10114 value
10115 }
10116 }
10117
10118 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayResponse {
10119 type Owned = Self;
10120
10121 #[inline(always)]
10122 fn inline_align(_context: fidl::encoding::Context) -> usize {
10123 8
10124 }
10125
10126 #[inline(always)]
10127 fn inline_size(_context: fidl::encoding::Context) -> usize {
10128 16
10129 }
10130 #[inline(always)]
10131 fn encode_is_copy() -> bool {
10132 true
10133 }
10134
10135 #[inline(always)]
10136 fn decode_is_copy() -> bool {
10137 true
10138 }
10139 }
10140
10141 unsafe impl<D: fidl::encoding::ResourceDialect>
10142 fidl::encoding::Encode<AudioRendererPlayResponse, D> for &AudioRendererPlayResponse
10143 {
10144 #[inline]
10145 unsafe fn encode(
10146 self,
10147 encoder: &mut fidl::encoding::Encoder<'_, D>,
10148 offset: usize,
10149 _depth: fidl::encoding::Depth,
10150 ) -> fidl::Result<()> {
10151 encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
10152 unsafe {
10153 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10155 (buf_ptr as *mut AudioRendererPlayResponse)
10156 .write_unaligned((self as *const AudioRendererPlayResponse).read());
10157 }
10160 Ok(())
10161 }
10162 }
10163 unsafe impl<
10164 D: fidl::encoding::ResourceDialect,
10165 T0: fidl::encoding::Encode<i64, D>,
10166 T1: fidl::encoding::Encode<i64, D>,
10167 > fidl::encoding::Encode<AudioRendererPlayResponse, D> for (T0, T1)
10168 {
10169 #[inline]
10170 unsafe fn encode(
10171 self,
10172 encoder: &mut fidl::encoding::Encoder<'_, D>,
10173 offset: usize,
10174 depth: fidl::encoding::Depth,
10175 ) -> fidl::Result<()> {
10176 encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
10177 self.0.encode(encoder, offset + 0, depth)?;
10181 self.1.encode(encoder, offset + 8, depth)?;
10182 Ok(())
10183 }
10184 }
10185
10186 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10187 for AudioRendererPlayResponse
10188 {
10189 #[inline(always)]
10190 fn new_empty() -> Self {
10191 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
10192 }
10193
10194 #[inline]
10195 unsafe fn decode(
10196 &mut self,
10197 decoder: &mut fidl::encoding::Decoder<'_, D>,
10198 offset: usize,
10199 _depth: fidl::encoding::Depth,
10200 ) -> fidl::Result<()> {
10201 decoder.debug_check_bounds::<Self>(offset);
10202 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10203 unsafe {
10206 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10207 }
10208 Ok(())
10209 }
10210 }
10211
10212 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPcmStreamTypeRequest {
10213 type Borrowed<'a> = &'a Self;
10214 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10215 value
10216 }
10217 }
10218
10219 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPcmStreamTypeRequest {
10220 type Owned = Self;
10221
10222 #[inline(always)]
10223 fn inline_align(_context: fidl::encoding::Context) -> usize {
10224 4
10225 }
10226
10227 #[inline(always)]
10228 fn inline_size(_context: fidl::encoding::Context) -> usize {
10229 12
10230 }
10231 }
10232
10233 unsafe impl<D: fidl::encoding::ResourceDialect>
10234 fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D>
10235 for &AudioRendererSetPcmStreamTypeRequest
10236 {
10237 #[inline]
10238 unsafe fn encode(
10239 self,
10240 encoder: &mut fidl::encoding::Encoder<'_, D>,
10241 offset: usize,
10242 _depth: fidl::encoding::Depth,
10243 ) -> fidl::Result<()> {
10244 encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10245 fidl::encoding::Encode::<AudioRendererSetPcmStreamTypeRequest, D>::encode(
10247 (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
10248 encoder,
10249 offset,
10250 _depth,
10251 )
10252 }
10253 }
10254 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
10255 fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D> for (T0,)
10256 {
10257 #[inline]
10258 unsafe fn encode(
10259 self,
10260 encoder: &mut fidl::encoding::Encoder<'_, D>,
10261 offset: usize,
10262 depth: fidl::encoding::Depth,
10263 ) -> fidl::Result<()> {
10264 encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10265 self.0.encode(encoder, offset + 0, depth)?;
10269 Ok(())
10270 }
10271 }
10272
10273 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10274 for AudioRendererSetPcmStreamTypeRequest
10275 {
10276 #[inline(always)]
10277 fn new_empty() -> Self {
10278 Self { type_: fidl::new_empty!(AudioStreamType, D) }
10279 }
10280
10281 #[inline]
10282 unsafe fn decode(
10283 &mut self,
10284 decoder: &mut fidl::encoding::Decoder<'_, D>,
10285 offset: usize,
10286 _depth: fidl::encoding::Depth,
10287 ) -> fidl::Result<()> {
10288 decoder.debug_check_bounds::<Self>(offset);
10289 fidl::decode!(AudioStreamType, D, &mut self.type_, decoder, offset + 0, _depth)?;
10291 Ok(())
10292 }
10293 }
10294
10295 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10296 type Borrowed<'a> = &'a Self;
10297 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10298 value
10299 }
10300 }
10301
10302 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10303 type Owned = Self;
10304
10305 #[inline(always)]
10306 fn inline_align(_context: fidl::encoding::Context) -> usize {
10307 4
10308 }
10309
10310 #[inline(always)]
10311 fn inline_size(_context: fidl::encoding::Context) -> usize {
10312 4
10313 }
10314 }
10315
10316 unsafe impl<D: fidl::encoding::ResourceDialect>
10317 fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D>
10318 for &AudioRendererSetPtsContinuityThresholdRequest
10319 {
10320 #[inline]
10321 unsafe fn encode(
10322 self,
10323 encoder: &mut fidl::encoding::Encoder<'_, D>,
10324 offset: usize,
10325 _depth: fidl::encoding::Depth,
10326 ) -> fidl::Result<()> {
10327 encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10328 fidl::encoding::Encode::<AudioRendererSetPtsContinuityThresholdRequest, D>::encode(
10330 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.threshold_seconds),),
10331 encoder,
10332 offset,
10333 _depth,
10334 )
10335 }
10336 }
10337 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
10338 fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D> for (T0,)
10339 {
10340 #[inline]
10341 unsafe fn encode(
10342 self,
10343 encoder: &mut fidl::encoding::Encoder<'_, D>,
10344 offset: usize,
10345 depth: fidl::encoding::Depth,
10346 ) -> fidl::Result<()> {
10347 encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10348 self.0.encode(encoder, offset + 0, depth)?;
10352 Ok(())
10353 }
10354 }
10355
10356 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10357 for AudioRendererSetPtsContinuityThresholdRequest
10358 {
10359 #[inline(always)]
10360 fn new_empty() -> Self {
10361 Self { threshold_seconds: fidl::new_empty!(f32, D) }
10362 }
10363
10364 #[inline]
10365 unsafe fn decode(
10366 &mut self,
10367 decoder: &mut fidl::encoding::Decoder<'_, D>,
10368 offset: usize,
10369 _depth: fidl::encoding::Depth,
10370 ) -> fidl::Result<()> {
10371 decoder.debug_check_bounds::<Self>(offset);
10372 fidl::decode!(f32, D, &mut self.threshold_seconds, decoder, offset + 0, _depth)?;
10374 Ok(())
10375 }
10376 }
10377
10378 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsUnitsRequest {
10379 type Borrowed<'a> = &'a Self;
10380 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10381 value
10382 }
10383 }
10384
10385 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsUnitsRequest {
10386 type Owned = Self;
10387
10388 #[inline(always)]
10389 fn inline_align(_context: fidl::encoding::Context) -> usize {
10390 4
10391 }
10392
10393 #[inline(always)]
10394 fn inline_size(_context: fidl::encoding::Context) -> usize {
10395 8
10396 }
10397 #[inline(always)]
10398 fn encode_is_copy() -> bool {
10399 true
10400 }
10401
10402 #[inline(always)]
10403 fn decode_is_copy() -> bool {
10404 true
10405 }
10406 }
10407
10408 unsafe impl<D: fidl::encoding::ResourceDialect>
10409 fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D>
10410 for &AudioRendererSetPtsUnitsRequest
10411 {
10412 #[inline]
10413 unsafe fn encode(
10414 self,
10415 encoder: &mut fidl::encoding::Encoder<'_, D>,
10416 offset: usize,
10417 _depth: fidl::encoding::Depth,
10418 ) -> fidl::Result<()> {
10419 encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10420 unsafe {
10421 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10423 (buf_ptr as *mut AudioRendererSetPtsUnitsRequest)
10424 .write_unaligned((self as *const AudioRendererSetPtsUnitsRequest).read());
10425 }
10428 Ok(())
10429 }
10430 }
10431 unsafe impl<
10432 D: fidl::encoding::ResourceDialect,
10433 T0: fidl::encoding::Encode<u32, D>,
10434 T1: fidl::encoding::Encode<u32, D>,
10435 > fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D> for (T0, T1)
10436 {
10437 #[inline]
10438 unsafe fn encode(
10439 self,
10440 encoder: &mut fidl::encoding::Encoder<'_, D>,
10441 offset: usize,
10442 depth: fidl::encoding::Depth,
10443 ) -> fidl::Result<()> {
10444 encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10445 self.0.encode(encoder, offset + 0, depth)?;
10449 self.1.encode(encoder, offset + 4, depth)?;
10450 Ok(())
10451 }
10452 }
10453
10454 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10455 for AudioRendererSetPtsUnitsRequest
10456 {
10457 #[inline(always)]
10458 fn new_empty() -> Self {
10459 Self {
10460 tick_per_second_numerator: fidl::new_empty!(u32, D),
10461 tick_per_second_denominator: fidl::new_empty!(u32, D),
10462 }
10463 }
10464
10465 #[inline]
10466 unsafe fn decode(
10467 &mut self,
10468 decoder: &mut fidl::encoding::Decoder<'_, D>,
10469 offset: usize,
10470 _depth: fidl::encoding::Depth,
10471 ) -> fidl::Result<()> {
10472 decoder.debug_check_bounds::<Self>(offset);
10473 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10474 unsafe {
10477 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10478 }
10479 Ok(())
10480 }
10481 }
10482
10483 impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsage2Request {
10484 type Borrowed<'a> = &'a Self;
10485 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10486 value
10487 }
10488 }
10489
10490 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsage2Request {
10491 type Owned = Self;
10492
10493 #[inline(always)]
10494 fn inline_align(_context: fidl::encoding::Context) -> usize {
10495 4
10496 }
10497
10498 #[inline(always)]
10499 fn inline_size(_context: fidl::encoding::Context) -> usize {
10500 4
10501 }
10502 }
10503
10504 unsafe impl<D: fidl::encoding::ResourceDialect>
10505 fidl::encoding::Encode<AudioRendererSetUsage2Request, D>
10506 for &AudioRendererSetUsage2Request
10507 {
10508 #[inline]
10509 unsafe fn encode(
10510 self,
10511 encoder: &mut fidl::encoding::Encoder<'_, D>,
10512 offset: usize,
10513 _depth: fidl::encoding::Depth,
10514 ) -> fidl::Result<()> {
10515 encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10516 fidl::encoding::Encode::<AudioRendererSetUsage2Request, D>::encode(
10518 (<AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage2),),
10519 encoder,
10520 offset,
10521 _depth,
10522 )
10523 }
10524 }
10525 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage2, D>>
10526 fidl::encoding::Encode<AudioRendererSetUsage2Request, D> for (T0,)
10527 {
10528 #[inline]
10529 unsafe fn encode(
10530 self,
10531 encoder: &mut fidl::encoding::Encoder<'_, D>,
10532 offset: usize,
10533 depth: fidl::encoding::Depth,
10534 ) -> fidl::Result<()> {
10535 encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10536 self.0.encode(encoder, offset + 0, depth)?;
10540 Ok(())
10541 }
10542 }
10543
10544 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10545 for AudioRendererSetUsage2Request
10546 {
10547 #[inline(always)]
10548 fn new_empty() -> Self {
10549 Self { usage2: fidl::new_empty!(AudioRenderUsage2, D) }
10550 }
10551
10552 #[inline]
10553 unsafe fn decode(
10554 &mut self,
10555 decoder: &mut fidl::encoding::Decoder<'_, D>,
10556 offset: usize,
10557 _depth: fidl::encoding::Depth,
10558 ) -> fidl::Result<()> {
10559 decoder.debug_check_bounds::<Self>(offset);
10560 fidl::decode!(AudioRenderUsage2, D, &mut self.usage2, decoder, offset + 0, _depth)?;
10562 Ok(())
10563 }
10564 }
10565
10566 impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsageRequest {
10567 type Borrowed<'a> = &'a Self;
10568 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10569 value
10570 }
10571 }
10572
10573 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsageRequest {
10574 type Owned = Self;
10575
10576 #[inline(always)]
10577 fn inline_align(_context: fidl::encoding::Context) -> usize {
10578 4
10579 }
10580
10581 #[inline(always)]
10582 fn inline_size(_context: fidl::encoding::Context) -> usize {
10583 4
10584 }
10585 }
10586
10587 unsafe impl<D: fidl::encoding::ResourceDialect>
10588 fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for &AudioRendererSetUsageRequest
10589 {
10590 #[inline]
10591 unsafe fn encode(
10592 self,
10593 encoder: &mut fidl::encoding::Encoder<'_, D>,
10594 offset: usize,
10595 _depth: fidl::encoding::Depth,
10596 ) -> fidl::Result<()> {
10597 encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10598 fidl::encoding::Encode::<AudioRendererSetUsageRequest, D>::encode(
10600 (<AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
10601 encoder,
10602 offset,
10603 _depth,
10604 )
10605 }
10606 }
10607 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage, D>>
10608 fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for (T0,)
10609 {
10610 #[inline]
10611 unsafe fn encode(
10612 self,
10613 encoder: &mut fidl::encoding::Encoder<'_, D>,
10614 offset: usize,
10615 depth: fidl::encoding::Depth,
10616 ) -> fidl::Result<()> {
10617 encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10618 self.0.encode(encoder, offset + 0, depth)?;
10622 Ok(())
10623 }
10624 }
10625
10626 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10627 for AudioRendererSetUsageRequest
10628 {
10629 #[inline(always)]
10630 fn new_empty() -> Self {
10631 Self { usage: fidl::new_empty!(AudioRenderUsage, D) }
10632 }
10633
10634 #[inline]
10635 unsafe fn decode(
10636 &mut self,
10637 decoder: &mut fidl::encoding::Decoder<'_, D>,
10638 offset: usize,
10639 _depth: fidl::encoding::Depth,
10640 ) -> fidl::Result<()> {
10641 decoder.debug_check_bounds::<Self>(offset);
10642 fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
10644 Ok(())
10645 }
10646 }
10647
10648 impl fidl::encoding::ValueTypeMarker for AudioStreamType {
10649 type Borrowed<'a> = &'a Self;
10650 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10651 value
10652 }
10653 }
10654
10655 unsafe impl fidl::encoding::TypeMarker for AudioStreamType {
10656 type Owned = Self;
10657
10658 #[inline(always)]
10659 fn inline_align(_context: fidl::encoding::Context) -> usize {
10660 4
10661 }
10662
10663 #[inline(always)]
10664 fn inline_size(_context: fidl::encoding::Context) -> usize {
10665 12
10666 }
10667 }
10668
10669 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioStreamType, D>
10670 for &AudioStreamType
10671 {
10672 #[inline]
10673 unsafe fn encode(
10674 self,
10675 encoder: &mut fidl::encoding::Encoder<'_, D>,
10676 offset: usize,
10677 _depth: fidl::encoding::Depth,
10678 ) -> fidl::Result<()> {
10679 encoder.debug_check_bounds::<AudioStreamType>(offset);
10680 fidl::encoding::Encode::<AudioStreamType, D>::encode(
10682 (
10683 <AudioSampleFormat as fidl::encoding::ValueTypeMarker>::borrow(
10684 &self.sample_format,
10685 ),
10686 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.channels),
10687 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
10688 ),
10689 encoder,
10690 offset,
10691 _depth,
10692 )
10693 }
10694 }
10695 unsafe impl<
10696 D: fidl::encoding::ResourceDialect,
10697 T0: fidl::encoding::Encode<AudioSampleFormat, D>,
10698 T1: fidl::encoding::Encode<u32, D>,
10699 T2: fidl::encoding::Encode<u32, D>,
10700 > fidl::encoding::Encode<AudioStreamType, D> for (T0, T1, T2)
10701 {
10702 #[inline]
10703 unsafe fn encode(
10704 self,
10705 encoder: &mut fidl::encoding::Encoder<'_, D>,
10706 offset: usize,
10707 depth: fidl::encoding::Depth,
10708 ) -> fidl::Result<()> {
10709 encoder.debug_check_bounds::<AudioStreamType>(offset);
10710 self.0.encode(encoder, offset + 0, depth)?;
10714 self.1.encode(encoder, offset + 4, depth)?;
10715 self.2.encode(encoder, offset + 8, depth)?;
10716 Ok(())
10717 }
10718 }
10719
10720 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioStreamType {
10721 #[inline(always)]
10722 fn new_empty() -> Self {
10723 Self {
10724 sample_format: fidl::new_empty!(AudioSampleFormat, D),
10725 channels: fidl::new_empty!(u32, D),
10726 frames_per_second: fidl::new_empty!(u32, D),
10727 }
10728 }
10729
10730 #[inline]
10731 unsafe fn decode(
10732 &mut self,
10733 decoder: &mut fidl::encoding::Decoder<'_, D>,
10734 offset: usize,
10735 _depth: fidl::encoding::Depth,
10736 ) -> fidl::Result<()> {
10737 decoder.debug_check_bounds::<Self>(offset);
10738 fidl::decode!(
10740 AudioSampleFormat,
10741 D,
10742 &mut self.sample_format,
10743 decoder,
10744 offset + 0,
10745 _depth
10746 )?;
10747 fidl::decode!(u32, D, &mut self.channels, decoder, offset + 4, _depth)?;
10748 fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
10749 Ok(())
10750 }
10751 }
10752
10753 impl fidl::encoding::ValueTypeMarker for Compression {
10754 type Borrowed<'a> = &'a Self;
10755 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10756 value
10757 }
10758 }
10759
10760 unsafe impl fidl::encoding::TypeMarker for Compression {
10761 type Owned = Self;
10762
10763 #[inline(always)]
10764 fn inline_align(_context: fidl::encoding::Context) -> usize {
10765 8
10766 }
10767
10768 #[inline(always)]
10769 fn inline_size(_context: fidl::encoding::Context) -> usize {
10770 32
10771 }
10772 }
10773
10774 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Compression, D>
10775 for &Compression
10776 {
10777 #[inline]
10778 unsafe fn encode(
10779 self,
10780 encoder: &mut fidl::encoding::Encoder<'_, D>,
10781 offset: usize,
10782 _depth: fidl::encoding::Depth,
10783 ) -> fidl::Result<()> {
10784 encoder.debug_check_bounds::<Compression>(offset);
10785 fidl::encoding::Encode::<Compression, D>::encode(
10787 (
10788 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
10789 <fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
10790 ),
10791 encoder, offset, _depth
10792 )
10793 }
10794 }
10795 unsafe impl<
10796 D: fidl::encoding::ResourceDialect,
10797 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
10798 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>, D>,
10799 > fidl::encoding::Encode<Compression, D> for (T0, T1)
10800 {
10801 #[inline]
10802 unsafe fn encode(
10803 self,
10804 encoder: &mut fidl::encoding::Encoder<'_, D>,
10805 offset: usize,
10806 depth: fidl::encoding::Depth,
10807 ) -> fidl::Result<()> {
10808 encoder.debug_check_bounds::<Compression>(offset);
10809 self.0.encode(encoder, offset + 0, depth)?;
10813 self.1.encode(encoder, offset + 16, depth)?;
10814 Ok(())
10815 }
10816 }
10817
10818 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Compression {
10819 #[inline(always)]
10820 fn new_empty() -> Self {
10821 Self {
10822 type_: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
10823 parameters: fidl::new_empty!(
10824 fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10825 D
10826 ),
10827 }
10828 }
10829
10830 #[inline]
10831 unsafe fn decode(
10832 &mut self,
10833 decoder: &mut fidl::encoding::Decoder<'_, D>,
10834 offset: usize,
10835 _depth: fidl::encoding::Depth,
10836 ) -> fidl::Result<()> {
10837 decoder.debug_check_bounds::<Self>(offset);
10838 fidl::decode!(
10840 fidl::encoding::BoundedString<256>,
10841 D,
10842 &mut self.type_,
10843 decoder,
10844 offset + 0,
10845 _depth
10846 )?;
10847 fidl::decode!(
10848 fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10849 D,
10850 &mut self.parameters,
10851 decoder,
10852 offset + 16,
10853 _depth
10854 )?;
10855 Ok(())
10856 }
10857 }
10858
10859 impl fidl::encoding::ValueTypeMarker for EncryptionPattern {
10860 type Borrowed<'a> = &'a Self;
10861 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10862 value
10863 }
10864 }
10865
10866 unsafe impl fidl::encoding::TypeMarker for EncryptionPattern {
10867 type Owned = Self;
10868
10869 #[inline(always)]
10870 fn inline_align(_context: fidl::encoding::Context) -> usize {
10871 4
10872 }
10873
10874 #[inline(always)]
10875 fn inline_size(_context: fidl::encoding::Context) -> usize {
10876 8
10877 }
10878 #[inline(always)]
10879 fn encode_is_copy() -> bool {
10880 true
10881 }
10882
10883 #[inline(always)]
10884 fn decode_is_copy() -> bool {
10885 true
10886 }
10887 }
10888
10889 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptionPattern, D>
10890 for &EncryptionPattern
10891 {
10892 #[inline]
10893 unsafe fn encode(
10894 self,
10895 encoder: &mut fidl::encoding::Encoder<'_, D>,
10896 offset: usize,
10897 _depth: fidl::encoding::Depth,
10898 ) -> fidl::Result<()> {
10899 encoder.debug_check_bounds::<EncryptionPattern>(offset);
10900 unsafe {
10901 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10903 (buf_ptr as *mut EncryptionPattern)
10904 .write_unaligned((self as *const EncryptionPattern).read());
10905 }
10908 Ok(())
10909 }
10910 }
10911 unsafe impl<
10912 D: fidl::encoding::ResourceDialect,
10913 T0: fidl::encoding::Encode<u32, D>,
10914 T1: fidl::encoding::Encode<u32, D>,
10915 > fidl::encoding::Encode<EncryptionPattern, D> for (T0, T1)
10916 {
10917 #[inline]
10918 unsafe fn encode(
10919 self,
10920 encoder: &mut fidl::encoding::Encoder<'_, D>,
10921 offset: usize,
10922 depth: fidl::encoding::Depth,
10923 ) -> fidl::Result<()> {
10924 encoder.debug_check_bounds::<EncryptionPattern>(offset);
10925 self.0.encode(encoder, offset + 0, depth)?;
10929 self.1.encode(encoder, offset + 4, depth)?;
10930 Ok(())
10931 }
10932 }
10933
10934 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptionPattern {
10935 #[inline(always)]
10936 fn new_empty() -> Self {
10937 Self {
10938 clear_blocks: fidl::new_empty!(u32, D),
10939 encrypted_blocks: fidl::new_empty!(u32, D),
10940 }
10941 }
10942
10943 #[inline]
10944 unsafe fn decode(
10945 &mut self,
10946 decoder: &mut fidl::encoding::Decoder<'_, D>,
10947 offset: usize,
10948 _depth: fidl::encoding::Depth,
10949 ) -> fidl::Result<()> {
10950 decoder.debug_check_bounds::<Self>(offset);
10951 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10952 unsafe {
10955 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10956 }
10957 Ok(())
10958 }
10959 }
10960
10961 impl fidl::encoding::ValueTypeMarker for Metadata {
10962 type Borrowed<'a> = &'a Self;
10963 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10964 value
10965 }
10966 }
10967
10968 unsafe impl fidl::encoding::TypeMarker for Metadata {
10969 type Owned = Self;
10970
10971 #[inline(always)]
10972 fn inline_align(_context: fidl::encoding::Context) -> usize {
10973 8
10974 }
10975
10976 #[inline(always)]
10977 fn inline_size(_context: fidl::encoding::Context) -> usize {
10978 16
10979 }
10980 }
10981
10982 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metadata, D> for &Metadata {
10983 #[inline]
10984 unsafe fn encode(
10985 self,
10986 encoder: &mut fidl::encoding::Encoder<'_, D>,
10987 offset: usize,
10988 _depth: fidl::encoding::Depth,
10989 ) -> fidl::Result<()> {
10990 encoder.debug_check_bounds::<Metadata>(offset);
10991 fidl::encoding::Encode::<Metadata, D>::encode(
10993 (
10994 <fidl::encoding::UnboundedVector<Property> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
10995 ),
10996 encoder, offset, _depth
10997 )
10998 }
10999 }
11000 unsafe impl<
11001 D: fidl::encoding::ResourceDialect,
11002 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Property>, D>,
11003 > fidl::encoding::Encode<Metadata, D> for (T0,)
11004 {
11005 #[inline]
11006 unsafe fn encode(
11007 self,
11008 encoder: &mut fidl::encoding::Encoder<'_, D>,
11009 offset: usize,
11010 depth: fidl::encoding::Depth,
11011 ) -> fidl::Result<()> {
11012 encoder.debug_check_bounds::<Metadata>(offset);
11013 self.0.encode(encoder, offset + 0, depth)?;
11017 Ok(())
11018 }
11019 }
11020
11021 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metadata {
11022 #[inline(always)]
11023 fn new_empty() -> Self {
11024 Self { properties: fidl::new_empty!(fidl::encoding::UnboundedVector<Property>, D) }
11025 }
11026
11027 #[inline]
11028 unsafe fn decode(
11029 &mut self,
11030 decoder: &mut fidl::encoding::Decoder<'_, D>,
11031 offset: usize,
11032 _depth: fidl::encoding::Depth,
11033 ) -> fidl::Result<()> {
11034 decoder.debug_check_bounds::<Self>(offset);
11035 fidl::decode!(
11037 fidl::encoding::UnboundedVector<Property>,
11038 D,
11039 &mut self.properties,
11040 decoder,
11041 offset + 0,
11042 _depth
11043 )?;
11044 Ok(())
11045 }
11046 }
11047
11048 impl fidl::encoding::ValueTypeMarker for Parameter {
11049 type Borrowed<'a> = &'a Self;
11050 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11051 value
11052 }
11053 }
11054
11055 unsafe impl fidl::encoding::TypeMarker for Parameter {
11056 type Owned = Self;
11057
11058 #[inline(always)]
11059 fn inline_align(_context: fidl::encoding::Context) -> usize {
11060 8
11061 }
11062
11063 #[inline(always)]
11064 fn inline_size(_context: fidl::encoding::Context) -> usize {
11065 48
11066 }
11067 }
11068
11069 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
11070 for &Parameter
11071 {
11072 #[inline]
11073 unsafe fn encode(
11074 self,
11075 encoder: &mut fidl::encoding::Encoder<'_, D>,
11076 offset: usize,
11077 _depth: fidl::encoding::Depth,
11078 ) -> fidl::Result<()> {
11079 encoder.debug_check_bounds::<Parameter>(offset);
11080 fidl::encoding::Encode::<Parameter, D>::encode(
11082 (
11083 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11084 &self.scope,
11085 ),
11086 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11087 &self.name,
11088 ),
11089 <Value as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
11090 ),
11091 encoder,
11092 offset,
11093 _depth,
11094 )
11095 }
11096 }
11097 unsafe impl<
11098 D: fidl::encoding::ResourceDialect,
11099 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11100 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11101 T2: fidl::encoding::Encode<Value, D>,
11102 > fidl::encoding::Encode<Parameter, D> for (T0, T1, T2)
11103 {
11104 #[inline]
11105 unsafe fn encode(
11106 self,
11107 encoder: &mut fidl::encoding::Encoder<'_, D>,
11108 offset: usize,
11109 depth: fidl::encoding::Depth,
11110 ) -> fidl::Result<()> {
11111 encoder.debug_check_bounds::<Parameter>(offset);
11112 self.0.encode(encoder, offset + 0, depth)?;
11116 self.1.encode(encoder, offset + 16, depth)?;
11117 self.2.encode(encoder, offset + 32, depth)?;
11118 Ok(())
11119 }
11120 }
11121
11122 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
11123 #[inline(always)]
11124 fn new_empty() -> Self {
11125 Self {
11126 scope: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11127 name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11128 value: fidl::new_empty!(Value, D),
11129 }
11130 }
11131
11132 #[inline]
11133 unsafe fn decode(
11134 &mut self,
11135 decoder: &mut fidl::encoding::Decoder<'_, D>,
11136 offset: usize,
11137 _depth: fidl::encoding::Depth,
11138 ) -> fidl::Result<()> {
11139 decoder.debug_check_bounds::<Self>(offset);
11140 fidl::decode!(
11142 fidl::encoding::UnboundedString,
11143 D,
11144 &mut self.scope,
11145 decoder,
11146 offset + 0,
11147 _depth
11148 )?;
11149 fidl::decode!(
11150 fidl::encoding::UnboundedString,
11151 D,
11152 &mut self.name,
11153 decoder,
11154 offset + 16,
11155 _depth
11156 )?;
11157 fidl::decode!(Value, D, &mut self.value, decoder, offset + 32, _depth)?;
11158 Ok(())
11159 }
11160 }
11161
11162 impl fidl::encoding::ValueTypeMarker for PcmFormat {
11163 type Borrowed<'a> = &'a Self;
11164 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11165 value
11166 }
11167 }
11168
11169 unsafe impl fidl::encoding::TypeMarker for PcmFormat {
11170 type Owned = Self;
11171
11172 #[inline(always)]
11173 fn inline_align(_context: fidl::encoding::Context) -> usize {
11174 8
11175 }
11176
11177 #[inline(always)]
11178 fn inline_size(_context: fidl::encoding::Context) -> usize {
11179 32
11180 }
11181 }
11182
11183 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormat, D>
11184 for &PcmFormat
11185 {
11186 #[inline]
11187 unsafe fn encode(
11188 self,
11189 encoder: &mut fidl::encoding::Encoder<'_, D>,
11190 offset: usize,
11191 _depth: fidl::encoding::Depth,
11192 ) -> fidl::Result<()> {
11193 encoder.debug_check_bounds::<PcmFormat>(offset);
11194 fidl::encoding::Encode::<PcmFormat, D>::encode(
11196 (
11197 <AudioPcmMode as fidl::encoding::ValueTypeMarker>::borrow(&self.pcm_mode),
11198 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.bits_per_sample),
11199 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
11200 <fidl::encoding::Vector<AudioChannelId, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_map),
11201 ),
11202 encoder, offset, _depth
11203 )
11204 }
11205 }
11206 unsafe impl<
11207 D: fidl::encoding::ResourceDialect,
11208 T0: fidl::encoding::Encode<AudioPcmMode, D>,
11209 T1: fidl::encoding::Encode<u32, D>,
11210 T2: fidl::encoding::Encode<u32, D>,
11211 T3: fidl::encoding::Encode<fidl::encoding::Vector<AudioChannelId, 16>, D>,
11212 > fidl::encoding::Encode<PcmFormat, D> for (T0, T1, T2, T3)
11213 {
11214 #[inline]
11215 unsafe fn encode(
11216 self,
11217 encoder: &mut fidl::encoding::Encoder<'_, D>,
11218 offset: usize,
11219 depth: fidl::encoding::Depth,
11220 ) -> fidl::Result<()> {
11221 encoder.debug_check_bounds::<PcmFormat>(offset);
11222 unsafe {
11225 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11226 (ptr as *mut u64).write_unaligned(0);
11227 }
11228 self.0.encode(encoder, offset + 0, depth)?;
11230 self.1.encode(encoder, offset + 4, depth)?;
11231 self.2.encode(encoder, offset + 8, depth)?;
11232 self.3.encode(encoder, offset + 16, depth)?;
11233 Ok(())
11234 }
11235 }
11236
11237 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormat {
11238 #[inline(always)]
11239 fn new_empty() -> Self {
11240 Self {
11241 pcm_mode: fidl::new_empty!(AudioPcmMode, D),
11242 bits_per_sample: fidl::new_empty!(u32, D),
11243 frames_per_second: fidl::new_empty!(u32, D),
11244 channel_map: fidl::new_empty!(fidl::encoding::Vector<AudioChannelId, 16>, D),
11245 }
11246 }
11247
11248 #[inline]
11249 unsafe fn decode(
11250 &mut self,
11251 decoder: &mut fidl::encoding::Decoder<'_, D>,
11252 offset: usize,
11253 _depth: fidl::encoding::Depth,
11254 ) -> fidl::Result<()> {
11255 decoder.debug_check_bounds::<Self>(offset);
11256 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11258 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11259 let mask = 0xffffffff00000000u64;
11260 let maskedval = padval & mask;
11261 if maskedval != 0 {
11262 return Err(fidl::Error::NonZeroPadding {
11263 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11264 });
11265 }
11266 fidl::decode!(AudioPcmMode, D, &mut self.pcm_mode, decoder, offset + 0, _depth)?;
11267 fidl::decode!(u32, D, &mut self.bits_per_sample, decoder, offset + 4, _depth)?;
11268 fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
11269 fidl::decode!(fidl::encoding::Vector<AudioChannelId, 16>, D, &mut self.channel_map, decoder, offset + 16, _depth)?;
11270 Ok(())
11271 }
11272 }
11273
11274 impl fidl::encoding::ValueTypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11275 type Borrowed<'a> = &'a Self;
11276 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11277 value
11278 }
11279 }
11280
11281 unsafe impl fidl::encoding::TypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11282 type Owned = Self;
11283
11284 #[inline(always)]
11285 fn inline_align(_context: fidl::encoding::Context) -> usize {
11286 8
11287 }
11288
11289 #[inline(always)]
11290 fn inline_size(_context: fidl::encoding::Context) -> usize {
11291 16
11292 }
11293 #[inline(always)]
11294 fn encode_is_copy() -> bool {
11295 true
11296 }
11297
11298 #[inline(always)]
11299 fn decode_is_copy() -> bool {
11300 true
11301 }
11302 }
11303
11304 unsafe impl<D: fidl::encoding::ResourceDialect>
11305 fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11306 for &ProfileProviderRegisterHandlerWithCapacityResponse
11307 {
11308 #[inline]
11309 unsafe fn encode(
11310 self,
11311 encoder: &mut fidl::encoding::Encoder<'_, D>,
11312 offset: usize,
11313 _depth: fidl::encoding::Depth,
11314 ) -> fidl::Result<()> {
11315 encoder
11316 .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11317 unsafe {
11318 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11320 (buf_ptr as *mut ProfileProviderRegisterHandlerWithCapacityResponse)
11321 .write_unaligned(
11322 (self as *const ProfileProviderRegisterHandlerWithCapacityResponse).read(),
11323 );
11324 }
11327 Ok(())
11328 }
11329 }
11330 unsafe impl<
11331 D: fidl::encoding::ResourceDialect,
11332 T0: fidl::encoding::Encode<i64, D>,
11333 T1: fidl::encoding::Encode<i64, D>,
11334 > fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11335 for (T0, T1)
11336 {
11337 #[inline]
11338 unsafe fn encode(
11339 self,
11340 encoder: &mut fidl::encoding::Encoder<'_, D>,
11341 offset: usize,
11342 depth: fidl::encoding::Depth,
11343 ) -> fidl::Result<()> {
11344 encoder
11345 .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11346 self.0.encode(encoder, offset + 0, depth)?;
11350 self.1.encode(encoder, offset + 8, depth)?;
11351 Ok(())
11352 }
11353 }
11354
11355 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11356 for ProfileProviderRegisterHandlerWithCapacityResponse
11357 {
11358 #[inline(always)]
11359 fn new_empty() -> Self {
11360 Self { period: fidl::new_empty!(i64, D), capacity: fidl::new_empty!(i64, D) }
11361 }
11362
11363 #[inline]
11364 unsafe fn decode(
11365 &mut self,
11366 decoder: &mut fidl::encoding::Decoder<'_, D>,
11367 offset: usize,
11368 _depth: fidl::encoding::Depth,
11369 ) -> fidl::Result<()> {
11370 decoder.debug_check_bounds::<Self>(offset);
11371 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11372 unsafe {
11375 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
11376 }
11377 Ok(())
11378 }
11379 }
11380
11381 impl fidl::encoding::ValueTypeMarker for Property {
11382 type Borrowed<'a> = &'a Self;
11383 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11384 value
11385 }
11386 }
11387
11388 unsafe impl fidl::encoding::TypeMarker for Property {
11389 type Owned = Self;
11390
11391 #[inline(always)]
11392 fn inline_align(_context: fidl::encoding::Context) -> usize {
11393 8
11394 }
11395
11396 #[inline(always)]
11397 fn inline_size(_context: fidl::encoding::Context) -> usize {
11398 32
11399 }
11400 }
11401
11402 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Property, D> for &Property {
11403 #[inline]
11404 unsafe fn encode(
11405 self,
11406 encoder: &mut fidl::encoding::Encoder<'_, D>,
11407 offset: usize,
11408 _depth: fidl::encoding::Depth,
11409 ) -> fidl::Result<()> {
11410 encoder.debug_check_bounds::<Property>(offset);
11411 fidl::encoding::Encode::<Property, D>::encode(
11413 (
11414 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11415 &self.label,
11416 ),
11417 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11418 &self.value,
11419 ),
11420 ),
11421 encoder,
11422 offset,
11423 _depth,
11424 )
11425 }
11426 }
11427 unsafe impl<
11428 D: fidl::encoding::ResourceDialect,
11429 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11430 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11431 > fidl::encoding::Encode<Property, D> for (T0, T1)
11432 {
11433 #[inline]
11434 unsafe fn encode(
11435 self,
11436 encoder: &mut fidl::encoding::Encoder<'_, D>,
11437 offset: usize,
11438 depth: fidl::encoding::Depth,
11439 ) -> fidl::Result<()> {
11440 encoder.debug_check_bounds::<Property>(offset);
11441 self.0.encode(encoder, offset + 0, depth)?;
11445 self.1.encode(encoder, offset + 16, depth)?;
11446 Ok(())
11447 }
11448 }
11449
11450 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Property {
11451 #[inline(always)]
11452 fn new_empty() -> Self {
11453 Self {
11454 label: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11455 value: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11456 }
11457 }
11458
11459 #[inline]
11460 unsafe fn decode(
11461 &mut self,
11462 decoder: &mut fidl::encoding::Decoder<'_, D>,
11463 offset: usize,
11464 _depth: fidl::encoding::Depth,
11465 ) -> fidl::Result<()> {
11466 decoder.debug_check_bounds::<Self>(offset);
11467 fidl::decode!(
11469 fidl::encoding::UnboundedString,
11470 D,
11471 &mut self.label,
11472 decoder,
11473 offset + 0,
11474 _depth
11475 )?;
11476 fidl::decode!(
11477 fidl::encoding::UnboundedString,
11478 D,
11479 &mut self.value,
11480 decoder,
11481 offset + 16,
11482 _depth
11483 )?;
11484 Ok(())
11485 }
11486 }
11487
11488 impl fidl::encoding::ValueTypeMarker for SbcEncoderSettings {
11489 type Borrowed<'a> = &'a Self;
11490 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11491 value
11492 }
11493 }
11494
11495 unsafe impl fidl::encoding::TypeMarker for SbcEncoderSettings {
11496 type Owned = Self;
11497
11498 #[inline(always)]
11499 fn inline_align(_context: fidl::encoding::Context) -> usize {
11500 8
11501 }
11502
11503 #[inline(always)]
11504 fn inline_size(_context: fidl::encoding::Context) -> usize {
11505 24
11506 }
11507 }
11508
11509 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SbcEncoderSettings, D>
11510 for &SbcEncoderSettings
11511 {
11512 #[inline]
11513 unsafe fn encode(
11514 self,
11515 encoder: &mut fidl::encoding::Encoder<'_, D>,
11516 offset: usize,
11517 _depth: fidl::encoding::Depth,
11518 ) -> fidl::Result<()> {
11519 encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11520 fidl::encoding::Encode::<SbcEncoderSettings, D>::encode(
11522 (
11523 <SbcSubBands as fidl::encoding::ValueTypeMarker>::borrow(&self.sub_bands),
11524 <SbcAllocation as fidl::encoding::ValueTypeMarker>::borrow(&self.allocation),
11525 <SbcBlockCount as fidl::encoding::ValueTypeMarker>::borrow(&self.block_count),
11526 <SbcChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
11527 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_pool),
11528 ),
11529 encoder,
11530 offset,
11531 _depth,
11532 )
11533 }
11534 }
11535 unsafe impl<
11536 D: fidl::encoding::ResourceDialect,
11537 T0: fidl::encoding::Encode<SbcSubBands, D>,
11538 T1: fidl::encoding::Encode<SbcAllocation, D>,
11539 T2: fidl::encoding::Encode<SbcBlockCount, D>,
11540 T3: fidl::encoding::Encode<SbcChannelMode, D>,
11541 T4: fidl::encoding::Encode<u64, D>,
11542 > fidl::encoding::Encode<SbcEncoderSettings, D> for (T0, T1, T2, T3, T4)
11543 {
11544 #[inline]
11545 unsafe fn encode(
11546 self,
11547 encoder: &mut fidl::encoding::Encoder<'_, D>,
11548 offset: usize,
11549 depth: fidl::encoding::Depth,
11550 ) -> fidl::Result<()> {
11551 encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11552 self.0.encode(encoder, offset + 0, depth)?;
11556 self.1.encode(encoder, offset + 4, depth)?;
11557 self.2.encode(encoder, offset + 8, depth)?;
11558 self.3.encode(encoder, offset + 12, depth)?;
11559 self.4.encode(encoder, offset + 16, depth)?;
11560 Ok(())
11561 }
11562 }
11563
11564 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcEncoderSettings {
11565 #[inline(always)]
11566 fn new_empty() -> Self {
11567 Self {
11568 sub_bands: fidl::new_empty!(SbcSubBands, D),
11569 allocation: fidl::new_empty!(SbcAllocation, D),
11570 block_count: fidl::new_empty!(SbcBlockCount, D),
11571 channel_mode: fidl::new_empty!(SbcChannelMode, D),
11572 bit_pool: fidl::new_empty!(u64, D),
11573 }
11574 }
11575
11576 #[inline]
11577 unsafe fn decode(
11578 &mut self,
11579 decoder: &mut fidl::encoding::Decoder<'_, D>,
11580 offset: usize,
11581 _depth: fidl::encoding::Depth,
11582 ) -> fidl::Result<()> {
11583 decoder.debug_check_bounds::<Self>(offset);
11584 fidl::decode!(SbcSubBands, D, &mut self.sub_bands, decoder, offset + 0, _depth)?;
11586 fidl::decode!(SbcAllocation, D, &mut self.allocation, decoder, offset + 4, _depth)?;
11587 fidl::decode!(SbcBlockCount, D, &mut self.block_count, decoder, offset + 8, _depth)?;
11588 fidl::decode!(SbcChannelMode, D, &mut self.channel_mode, decoder, offset + 12, _depth)?;
11589 fidl::decode!(u64, D, &mut self.bit_pool, decoder, offset + 16, _depth)?;
11590 Ok(())
11591 }
11592 }
11593
11594 impl fidl::encoding::ValueTypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11595 type Borrowed<'a> = &'a Self;
11596 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11597 value
11598 }
11599 }
11600
11601 unsafe impl fidl::encoding::TypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11602 type Owned = Self;
11603
11604 #[inline(always)]
11605 fn inline_align(_context: fidl::encoding::Context) -> usize {
11606 4
11607 }
11608
11609 #[inline(always)]
11610 fn inline_size(_context: fidl::encoding::Context) -> usize {
11611 4
11612 }
11613 #[inline(always)]
11614 fn encode_is_copy() -> bool {
11615 true
11616 }
11617
11618 #[inline(always)]
11619 fn decode_is_copy() -> bool {
11620 true
11621 }
11622 }
11623
11624 unsafe impl<D: fidl::encoding::ResourceDialect>
11625 fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D>
11626 for &StreamBufferSetRemovePayloadBufferRequest
11627 {
11628 #[inline]
11629 unsafe fn encode(
11630 self,
11631 encoder: &mut fidl::encoding::Encoder<'_, D>,
11632 offset: usize,
11633 _depth: fidl::encoding::Depth,
11634 ) -> fidl::Result<()> {
11635 encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11636 unsafe {
11637 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11639 (buf_ptr as *mut StreamBufferSetRemovePayloadBufferRequest).write_unaligned(
11640 (self as *const StreamBufferSetRemovePayloadBufferRequest).read(),
11641 );
11642 }
11645 Ok(())
11646 }
11647 }
11648 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
11649 fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D> for (T0,)
11650 {
11651 #[inline]
11652 unsafe fn encode(
11653 self,
11654 encoder: &mut fidl::encoding::Encoder<'_, D>,
11655 offset: usize,
11656 depth: fidl::encoding::Depth,
11657 ) -> fidl::Result<()> {
11658 encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11659 self.0.encode(encoder, offset + 0, depth)?;
11663 Ok(())
11664 }
11665 }
11666
11667 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11668 for StreamBufferSetRemovePayloadBufferRequest
11669 {
11670 #[inline(always)]
11671 fn new_empty() -> Self {
11672 Self { id: fidl::new_empty!(u32, D) }
11673 }
11674
11675 #[inline]
11676 unsafe fn decode(
11677 &mut self,
11678 decoder: &mut fidl::encoding::Decoder<'_, D>,
11679 offset: usize,
11680 _depth: fidl::encoding::Depth,
11681 ) -> fidl::Result<()> {
11682 decoder.debug_check_bounds::<Self>(offset);
11683 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11684 unsafe {
11687 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
11688 }
11689 Ok(())
11690 }
11691 }
11692
11693 impl fidl::encoding::ValueTypeMarker for StreamPacket {
11694 type Borrowed<'a> = &'a Self;
11695 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11696 value
11697 }
11698 }
11699
11700 unsafe impl fidl::encoding::TypeMarker for StreamPacket {
11701 type Owned = Self;
11702
11703 #[inline(always)]
11704 fn inline_align(_context: fidl::encoding::Context) -> usize {
11705 8
11706 }
11707
11708 #[inline(always)]
11709 fn inline_size(_context: fidl::encoding::Context) -> usize {
11710 56
11711 }
11712 }
11713
11714 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamPacket, D>
11715 for &StreamPacket
11716 {
11717 #[inline]
11718 unsafe fn encode(
11719 self,
11720 encoder: &mut fidl::encoding::Encoder<'_, D>,
11721 offset: usize,
11722 _depth: fidl::encoding::Depth,
11723 ) -> fidl::Result<()> {
11724 encoder.debug_check_bounds::<StreamPacket>(offset);
11725 unsafe {
11726 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11728 (buf_ptr as *mut StreamPacket)
11729 .write_unaligned((self as *const StreamPacket).read());
11730 let padding_ptr = buf_ptr.offset(8) as *mut u64;
11733 let padding_mask = 0xffffffff00000000u64;
11734 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11735 let padding_ptr = buf_ptr.offset(32) as *mut u64;
11736 let padding_mask = 0xffffffff00000000u64;
11737 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11738 }
11739 Ok(())
11740 }
11741 }
11742 unsafe impl<
11743 D: fidl::encoding::ResourceDialect,
11744 T0: fidl::encoding::Encode<i64, D>,
11745 T1: fidl::encoding::Encode<u32, D>,
11746 T2: fidl::encoding::Encode<u64, D>,
11747 T3: fidl::encoding::Encode<u64, D>,
11748 T4: fidl::encoding::Encode<u32, D>,
11749 T5: fidl::encoding::Encode<u64, D>,
11750 T6: fidl::encoding::Encode<u64, D>,
11751 > fidl::encoding::Encode<StreamPacket, D> for (T0, T1, T2, T3, T4, T5, T6)
11752 {
11753 #[inline]
11754 unsafe fn encode(
11755 self,
11756 encoder: &mut fidl::encoding::Encoder<'_, D>,
11757 offset: usize,
11758 depth: fidl::encoding::Depth,
11759 ) -> fidl::Result<()> {
11760 encoder.debug_check_bounds::<StreamPacket>(offset);
11761 unsafe {
11764 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11765 (ptr as *mut u64).write_unaligned(0);
11766 }
11767 unsafe {
11768 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
11769 (ptr as *mut u64).write_unaligned(0);
11770 }
11771 self.0.encode(encoder, offset + 0, depth)?;
11773 self.1.encode(encoder, offset + 8, depth)?;
11774 self.2.encode(encoder, offset + 16, depth)?;
11775 self.3.encode(encoder, offset + 24, depth)?;
11776 self.4.encode(encoder, offset + 32, depth)?;
11777 self.5.encode(encoder, offset + 40, depth)?;
11778 self.6.encode(encoder, offset + 48, depth)?;
11779 Ok(())
11780 }
11781 }
11782
11783 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamPacket {
11784 #[inline(always)]
11785 fn new_empty() -> Self {
11786 Self {
11787 pts: fidl::new_empty!(i64, D),
11788 payload_buffer_id: fidl::new_empty!(u32, D),
11789 payload_offset: fidl::new_empty!(u64, D),
11790 payload_size: fidl::new_empty!(u64, D),
11791 flags: fidl::new_empty!(u32, D),
11792 buffer_config: fidl::new_empty!(u64, D),
11793 stream_segment_id: fidl::new_empty!(u64, D),
11794 }
11795 }
11796
11797 #[inline]
11798 unsafe fn decode(
11799 &mut self,
11800 decoder: &mut fidl::encoding::Decoder<'_, D>,
11801 offset: usize,
11802 _depth: fidl::encoding::Depth,
11803 ) -> fidl::Result<()> {
11804 decoder.debug_check_bounds::<Self>(offset);
11805 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11806 let ptr = unsafe { buf_ptr.offset(8) };
11808 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11809 let mask = 0xffffffff00000000u64;
11810 let maskedval = padval & mask;
11811 if maskedval != 0 {
11812 return Err(fidl::Error::NonZeroPadding {
11813 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11814 });
11815 }
11816 let ptr = unsafe { buf_ptr.offset(32) };
11817 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11818 let mask = 0xffffffff00000000u64;
11819 let maskedval = padval & mask;
11820 if maskedval != 0 {
11821 return Err(fidl::Error::NonZeroPadding {
11822 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
11823 });
11824 }
11825 unsafe {
11827 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
11828 }
11829 Ok(())
11830 }
11831 }
11832
11833 impl fidl::encoding::ValueTypeMarker for StreamProcessorCloseCurrentStreamRequest {
11834 type Borrowed<'a> = &'a Self;
11835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11836 value
11837 }
11838 }
11839
11840 unsafe impl fidl::encoding::TypeMarker for StreamProcessorCloseCurrentStreamRequest {
11841 type Owned = Self;
11842
11843 #[inline(always)]
11844 fn inline_align(_context: fidl::encoding::Context) -> usize {
11845 8
11846 }
11847
11848 #[inline(always)]
11849 fn inline_size(_context: fidl::encoding::Context) -> usize {
11850 16
11851 }
11852 }
11853
11854 unsafe impl<D: fidl::encoding::ResourceDialect>
11855 fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D>
11856 for &StreamProcessorCloseCurrentStreamRequest
11857 {
11858 #[inline]
11859 unsafe fn encode(
11860 self,
11861 encoder: &mut fidl::encoding::Encoder<'_, D>,
11862 offset: usize,
11863 _depth: fidl::encoding::Depth,
11864 ) -> fidl::Result<()> {
11865 encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11866 fidl::encoding::Encode::<StreamProcessorCloseCurrentStreamRequest, D>::encode(
11868 (
11869 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
11870 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_input_buffers),
11871 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_output_buffers),
11872 ),
11873 encoder,
11874 offset,
11875 _depth,
11876 )
11877 }
11878 }
11879 unsafe impl<
11880 D: fidl::encoding::ResourceDialect,
11881 T0: fidl::encoding::Encode<u64, D>,
11882 T1: fidl::encoding::Encode<bool, D>,
11883 T2: fidl::encoding::Encode<bool, D>,
11884 > fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D> for (T0, T1, T2)
11885 {
11886 #[inline]
11887 unsafe fn encode(
11888 self,
11889 encoder: &mut fidl::encoding::Encoder<'_, D>,
11890 offset: usize,
11891 depth: fidl::encoding::Depth,
11892 ) -> fidl::Result<()> {
11893 encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11894 unsafe {
11897 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11898 (ptr as *mut u64).write_unaligned(0);
11899 }
11900 self.0.encode(encoder, offset + 0, depth)?;
11902 self.1.encode(encoder, offset + 8, depth)?;
11903 self.2.encode(encoder, offset + 9, depth)?;
11904 Ok(())
11905 }
11906 }
11907
11908 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11909 for StreamProcessorCloseCurrentStreamRequest
11910 {
11911 #[inline(always)]
11912 fn new_empty() -> Self {
11913 Self {
11914 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
11915 release_input_buffers: fidl::new_empty!(bool, D),
11916 release_output_buffers: fidl::new_empty!(bool, D),
11917 }
11918 }
11919
11920 #[inline]
11921 unsafe fn decode(
11922 &mut self,
11923 decoder: &mut fidl::encoding::Decoder<'_, D>,
11924 offset: usize,
11925 _depth: fidl::encoding::Depth,
11926 ) -> fidl::Result<()> {
11927 decoder.debug_check_bounds::<Self>(offset);
11928 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11930 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11931 let mask = 0xffffffffffff0000u64;
11932 let maskedval = padval & mask;
11933 if maskedval != 0 {
11934 return Err(fidl::Error::NonZeroPadding {
11935 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11936 });
11937 }
11938 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
11939 fidl::decode!(bool, D, &mut self.release_input_buffers, decoder, offset + 8, _depth)?;
11940 fidl::decode!(bool, D, &mut self.release_output_buffers, decoder, offset + 9, _depth)?;
11941 Ok(())
11942 }
11943 }
11944
11945 impl fidl::encoding::ValueTypeMarker for StreamProcessorCompleteOutputBufferPartialSettingsRequest {
11946 type Borrowed<'a> = &'a Self;
11947 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11948 value
11949 }
11950 }
11951
11952 unsafe impl fidl::encoding::TypeMarker
11953 for StreamProcessorCompleteOutputBufferPartialSettingsRequest
11954 {
11955 type Owned = Self;
11956
11957 #[inline(always)]
11958 fn inline_align(_context: fidl::encoding::Context) -> usize {
11959 8
11960 }
11961
11962 #[inline(always)]
11963 fn inline_size(_context: fidl::encoding::Context) -> usize {
11964 8
11965 }
11966 #[inline(always)]
11967 fn encode_is_copy() -> bool {
11968 true
11969 }
11970
11971 #[inline(always)]
11972 fn decode_is_copy() -> bool {
11973 true
11974 }
11975 }
11976
11977 unsafe impl<D: fidl::encoding::ResourceDialect>
11978 fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
11979 for &StreamProcessorCompleteOutputBufferPartialSettingsRequest
11980 {
11981 #[inline]
11982 unsafe fn encode(
11983 self,
11984 encoder: &mut fidl::encoding::Encoder<'_, D>,
11985 offset: usize,
11986 _depth: fidl::encoding::Depth,
11987 ) -> fidl::Result<()> {
11988 encoder
11989 .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
11990 offset,
11991 );
11992 unsafe {
11993 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11995 (buf_ptr as *mut StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11996 .write_unaligned(
11997 (self as *const StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11998 .read(),
11999 );
12000 }
12003 Ok(())
12004 }
12005 }
12006 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12007 fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
12008 for (T0,)
12009 {
12010 #[inline]
12011 unsafe fn encode(
12012 self,
12013 encoder: &mut fidl::encoding::Encoder<'_, D>,
12014 offset: usize,
12015 depth: fidl::encoding::Depth,
12016 ) -> fidl::Result<()> {
12017 encoder
12018 .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
12019 offset,
12020 );
12021 self.0.encode(encoder, offset + 0, depth)?;
12025 Ok(())
12026 }
12027 }
12028
12029 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12030 for StreamProcessorCompleteOutputBufferPartialSettingsRequest
12031 {
12032 #[inline(always)]
12033 fn new_empty() -> Self {
12034 Self { buffer_lifetime_ordinal: fidl::new_empty!(u64, D) }
12035 }
12036
12037 #[inline]
12038 unsafe fn decode(
12039 &mut self,
12040 decoder: &mut fidl::encoding::Decoder<'_, D>,
12041 offset: usize,
12042 _depth: fidl::encoding::Depth,
12043 ) -> fidl::Result<()> {
12044 decoder.debug_check_bounds::<Self>(offset);
12045 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12046 unsafe {
12049 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12050 }
12051 Ok(())
12052 }
12053 }
12054
12055 impl fidl::encoding::ValueTypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
12056 type Borrowed<'a> = &'a Self;
12057 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12058 value
12059 }
12060 }
12061
12062 unsafe impl fidl::encoding::TypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
12063 type Owned = Self;
12064
12065 #[inline(always)]
12066 fn inline_align(_context: fidl::encoding::Context) -> usize {
12067 8
12068 }
12069
12070 #[inline(always)]
12071 fn inline_size(_context: fidl::encoding::Context) -> usize {
12072 8
12073 }
12074 #[inline(always)]
12075 fn encode_is_copy() -> bool {
12076 true
12077 }
12078
12079 #[inline(always)]
12080 fn decode_is_copy() -> bool {
12081 true
12082 }
12083 }
12084
12085 unsafe impl<D: fidl::encoding::ResourceDialect>
12086 fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D>
12087 for &StreamProcessorFlushEndOfStreamAndCloseStreamRequest
12088 {
12089 #[inline]
12090 unsafe fn encode(
12091 self,
12092 encoder: &mut fidl::encoding::Encoder<'_, D>,
12093 offset: usize,
12094 _depth: fidl::encoding::Depth,
12095 ) -> fidl::Result<()> {
12096 encoder
12097 .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
12098 unsafe {
12099 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12101 (buf_ptr as *mut StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
12102 .write_unaligned(
12103 (self as *const StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
12104 .read(),
12105 );
12106 }
12109 Ok(())
12110 }
12111 }
12112 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12113 fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D> for (T0,)
12114 {
12115 #[inline]
12116 unsafe fn encode(
12117 self,
12118 encoder: &mut fidl::encoding::Encoder<'_, D>,
12119 offset: usize,
12120 depth: fidl::encoding::Depth,
12121 ) -> fidl::Result<()> {
12122 encoder
12123 .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
12124 self.0.encode(encoder, offset + 0, depth)?;
12128 Ok(())
12129 }
12130 }
12131
12132 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12133 for StreamProcessorFlushEndOfStreamAndCloseStreamRequest
12134 {
12135 #[inline(always)]
12136 fn new_empty() -> Self {
12137 Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
12138 }
12139
12140 #[inline]
12141 unsafe fn decode(
12142 &mut self,
12143 decoder: &mut fidl::encoding::Decoder<'_, D>,
12144 offset: usize,
12145 _depth: fidl::encoding::Depth,
12146 ) -> fidl::Result<()> {
12147 decoder.debug_check_bounds::<Self>(offset);
12148 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12149 unsafe {
12152 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12153 }
12154 Ok(())
12155 }
12156 }
12157
12158 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnFreeInputPacketRequest {
12159 type Borrowed<'a> = &'a Self;
12160 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12161 value
12162 }
12163 }
12164
12165 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnFreeInputPacketRequest {
12166 type Owned = Self;
12167
12168 #[inline(always)]
12169 fn inline_align(_context: fidl::encoding::Context) -> usize {
12170 8
12171 }
12172
12173 #[inline(always)]
12174 fn inline_size(_context: fidl::encoding::Context) -> usize {
12175 16
12176 }
12177 }
12178
12179 unsafe impl<D: fidl::encoding::ResourceDialect>
12180 fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D>
12181 for &StreamProcessorOnFreeInputPacketRequest
12182 {
12183 #[inline]
12184 unsafe fn encode(
12185 self,
12186 encoder: &mut fidl::encoding::Encoder<'_, D>,
12187 offset: usize,
12188 _depth: fidl::encoding::Depth,
12189 ) -> fidl::Result<()> {
12190 encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
12191 fidl::encoding::Encode::<StreamProcessorOnFreeInputPacketRequest, D>::encode(
12193 (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
12194 &self.free_input_packet,
12195 ),),
12196 encoder,
12197 offset,
12198 _depth,
12199 )
12200 }
12201 }
12202 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
12203 fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D> for (T0,)
12204 {
12205 #[inline]
12206 unsafe fn encode(
12207 self,
12208 encoder: &mut fidl::encoding::Encoder<'_, D>,
12209 offset: usize,
12210 depth: fidl::encoding::Depth,
12211 ) -> fidl::Result<()> {
12212 encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
12213 self.0.encode(encoder, offset + 0, depth)?;
12217 Ok(())
12218 }
12219 }
12220
12221 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12222 for StreamProcessorOnFreeInputPacketRequest
12223 {
12224 #[inline(always)]
12225 fn new_empty() -> Self {
12226 Self { free_input_packet: fidl::new_empty!(PacketHeader, D) }
12227 }
12228
12229 #[inline]
12230 unsafe fn decode(
12231 &mut self,
12232 decoder: &mut fidl::encoding::Decoder<'_, D>,
12233 offset: usize,
12234 _depth: fidl::encoding::Depth,
12235 ) -> fidl::Result<()> {
12236 decoder.debug_check_bounds::<Self>(offset);
12237 fidl::decode!(
12239 PacketHeader,
12240 D,
12241 &mut self.free_input_packet,
12242 decoder,
12243 offset + 0,
12244 _depth
12245 )?;
12246 Ok(())
12247 }
12248 }
12249
12250 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnInputConstraintsRequest {
12251 type Borrowed<'a> = &'a Self;
12252 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12253 value
12254 }
12255 }
12256
12257 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnInputConstraintsRequest {
12258 type Owned = Self;
12259
12260 #[inline(always)]
12261 fn inline_align(_context: fidl::encoding::Context) -> usize {
12262 8
12263 }
12264
12265 #[inline(always)]
12266 fn inline_size(_context: fidl::encoding::Context) -> usize {
12267 16
12268 }
12269 }
12270
12271 unsafe impl<D: fidl::encoding::ResourceDialect>
12272 fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D>
12273 for &StreamProcessorOnInputConstraintsRequest
12274 {
12275 #[inline]
12276 unsafe fn encode(
12277 self,
12278 encoder: &mut fidl::encoding::Encoder<'_, D>,
12279 offset: usize,
12280 _depth: fidl::encoding::Depth,
12281 ) -> fidl::Result<()> {
12282 encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12283 fidl::encoding::Encode::<StreamProcessorOnInputConstraintsRequest, D>::encode(
12285 (<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12286 &self.input_constraints,
12287 ),),
12288 encoder,
12289 offset,
12290 _depth,
12291 )
12292 }
12293 }
12294 unsafe impl<
12295 D: fidl::encoding::ResourceDialect,
12296 T0: fidl::encoding::Encode<StreamBufferConstraints, D>,
12297 > fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D> for (T0,)
12298 {
12299 #[inline]
12300 unsafe fn encode(
12301 self,
12302 encoder: &mut fidl::encoding::Encoder<'_, D>,
12303 offset: usize,
12304 depth: fidl::encoding::Depth,
12305 ) -> fidl::Result<()> {
12306 encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12307 self.0.encode(encoder, offset + 0, depth)?;
12311 Ok(())
12312 }
12313 }
12314
12315 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12316 for StreamProcessorOnInputConstraintsRequest
12317 {
12318 #[inline(always)]
12319 fn new_empty() -> Self {
12320 Self { input_constraints: fidl::new_empty!(StreamBufferConstraints, D) }
12321 }
12322
12323 #[inline]
12324 unsafe fn decode(
12325 &mut self,
12326 decoder: &mut fidl::encoding::Decoder<'_, D>,
12327 offset: usize,
12328 _depth: fidl::encoding::Depth,
12329 ) -> fidl::Result<()> {
12330 decoder.debug_check_bounds::<Self>(offset);
12331 fidl::decode!(
12333 StreamBufferConstraints,
12334 D,
12335 &mut self.input_constraints,
12336 decoder,
12337 offset + 0,
12338 _depth
12339 )?;
12340 Ok(())
12341 }
12342 }
12343
12344 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputConstraintsRequest {
12345 type Borrowed<'a> = &'a Self;
12346 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12347 value
12348 }
12349 }
12350
12351 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputConstraintsRequest {
12352 type Owned = Self;
12353
12354 #[inline(always)]
12355 fn inline_align(_context: fidl::encoding::Context) -> usize {
12356 8
12357 }
12358
12359 #[inline(always)]
12360 fn inline_size(_context: fidl::encoding::Context) -> usize {
12361 16
12362 }
12363 }
12364
12365 unsafe impl<D: fidl::encoding::ResourceDialect>
12366 fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D>
12367 for &StreamProcessorOnOutputConstraintsRequest
12368 {
12369 #[inline]
12370 unsafe fn encode(
12371 self,
12372 encoder: &mut fidl::encoding::Encoder<'_, D>,
12373 offset: usize,
12374 _depth: fidl::encoding::Depth,
12375 ) -> fidl::Result<()> {
12376 encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12377 fidl::encoding::Encode::<StreamProcessorOnOutputConstraintsRequest, D>::encode(
12379 (<StreamOutputConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12380 &self.output_config,
12381 ),),
12382 encoder,
12383 offset,
12384 _depth,
12385 )
12386 }
12387 }
12388 unsafe impl<
12389 D: fidl::encoding::ResourceDialect,
12390 T0: fidl::encoding::Encode<StreamOutputConstraints, D>,
12391 > fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D> for (T0,)
12392 {
12393 #[inline]
12394 unsafe fn encode(
12395 self,
12396 encoder: &mut fidl::encoding::Encoder<'_, D>,
12397 offset: usize,
12398 depth: fidl::encoding::Depth,
12399 ) -> fidl::Result<()> {
12400 encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12401 self.0.encode(encoder, offset + 0, depth)?;
12405 Ok(())
12406 }
12407 }
12408
12409 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12410 for StreamProcessorOnOutputConstraintsRequest
12411 {
12412 #[inline(always)]
12413 fn new_empty() -> Self {
12414 Self { output_config: fidl::new_empty!(StreamOutputConstraints, D) }
12415 }
12416
12417 #[inline]
12418 unsafe fn decode(
12419 &mut self,
12420 decoder: &mut fidl::encoding::Decoder<'_, D>,
12421 offset: usize,
12422 _depth: fidl::encoding::Depth,
12423 ) -> fidl::Result<()> {
12424 decoder.debug_check_bounds::<Self>(offset);
12425 fidl::decode!(
12427 StreamOutputConstraints,
12428 D,
12429 &mut self.output_config,
12430 decoder,
12431 offset + 0,
12432 _depth
12433 )?;
12434 Ok(())
12435 }
12436 }
12437
12438 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12439 type Borrowed<'a> = &'a Self;
12440 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12441 value
12442 }
12443 }
12444
12445 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12446 type Owned = Self;
12447
12448 #[inline(always)]
12449 fn inline_align(_context: fidl::encoding::Context) -> usize {
12450 8
12451 }
12452
12453 #[inline(always)]
12454 fn inline_size(_context: fidl::encoding::Context) -> usize {
12455 16
12456 }
12457 }
12458
12459 unsafe impl<D: fidl::encoding::ResourceDialect>
12460 fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D>
12461 for &StreamProcessorOnOutputEndOfStreamRequest
12462 {
12463 #[inline]
12464 unsafe fn encode(
12465 self,
12466 encoder: &mut fidl::encoding::Encoder<'_, D>,
12467 offset: usize,
12468 _depth: fidl::encoding::Depth,
12469 ) -> fidl::Result<()> {
12470 encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12471 fidl::encoding::Encode::<StreamProcessorOnOutputEndOfStreamRequest, D>::encode(
12473 (
12474 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12475 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12476 ),
12477 encoder,
12478 offset,
12479 _depth,
12480 )
12481 }
12482 }
12483 unsafe impl<
12484 D: fidl::encoding::ResourceDialect,
12485 T0: fidl::encoding::Encode<u64, D>,
12486 T1: fidl::encoding::Encode<bool, D>,
12487 > fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D> for (T0, T1)
12488 {
12489 #[inline]
12490 unsafe fn encode(
12491 self,
12492 encoder: &mut fidl::encoding::Encoder<'_, D>,
12493 offset: usize,
12494 depth: fidl::encoding::Depth,
12495 ) -> fidl::Result<()> {
12496 encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12497 unsafe {
12500 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12501 (ptr as *mut u64).write_unaligned(0);
12502 }
12503 self.0.encode(encoder, offset + 0, depth)?;
12505 self.1.encode(encoder, offset + 8, depth)?;
12506 Ok(())
12507 }
12508 }
12509
12510 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12511 for StreamProcessorOnOutputEndOfStreamRequest
12512 {
12513 #[inline(always)]
12514 fn new_empty() -> Self {
12515 Self {
12516 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12517 error_detected_before: fidl::new_empty!(bool, D),
12518 }
12519 }
12520
12521 #[inline]
12522 unsafe fn decode(
12523 &mut self,
12524 decoder: &mut fidl::encoding::Decoder<'_, D>,
12525 offset: usize,
12526 _depth: fidl::encoding::Depth,
12527 ) -> fidl::Result<()> {
12528 decoder.debug_check_bounds::<Self>(offset);
12529 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12531 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12532 let mask = 0xffffffffffffff00u64;
12533 let maskedval = padval & mask;
12534 if maskedval != 0 {
12535 return Err(fidl::Error::NonZeroPadding {
12536 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12537 });
12538 }
12539 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12540 fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 8, _depth)?;
12541 Ok(())
12542 }
12543 }
12544
12545 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputFormatRequest {
12546 type Borrowed<'a> = &'a Self;
12547 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12548 value
12549 }
12550 }
12551
12552 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputFormatRequest {
12553 type Owned = Self;
12554
12555 #[inline(always)]
12556 fn inline_align(_context: fidl::encoding::Context) -> usize {
12557 8
12558 }
12559
12560 #[inline(always)]
12561 fn inline_size(_context: fidl::encoding::Context) -> usize {
12562 16
12563 }
12564 }
12565
12566 unsafe impl<D: fidl::encoding::ResourceDialect>
12567 fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D>
12568 for &StreamProcessorOnOutputFormatRequest
12569 {
12570 #[inline]
12571 unsafe fn encode(
12572 self,
12573 encoder: &mut fidl::encoding::Encoder<'_, D>,
12574 offset: usize,
12575 _depth: fidl::encoding::Depth,
12576 ) -> fidl::Result<()> {
12577 encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12578 fidl::encoding::Encode::<StreamProcessorOnOutputFormatRequest, D>::encode(
12580 (<StreamOutputFormat as fidl::encoding::ValueTypeMarker>::borrow(
12581 &self.output_format,
12582 ),),
12583 encoder,
12584 offset,
12585 _depth,
12586 )
12587 }
12588 }
12589 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamOutputFormat, D>>
12590 fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D> for (T0,)
12591 {
12592 #[inline]
12593 unsafe fn encode(
12594 self,
12595 encoder: &mut fidl::encoding::Encoder<'_, D>,
12596 offset: usize,
12597 depth: fidl::encoding::Depth,
12598 ) -> fidl::Result<()> {
12599 encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12600 self.0.encode(encoder, offset + 0, depth)?;
12604 Ok(())
12605 }
12606 }
12607
12608 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12609 for StreamProcessorOnOutputFormatRequest
12610 {
12611 #[inline(always)]
12612 fn new_empty() -> Self {
12613 Self { output_format: fidl::new_empty!(StreamOutputFormat, D) }
12614 }
12615
12616 #[inline]
12617 unsafe fn decode(
12618 &mut self,
12619 decoder: &mut fidl::encoding::Decoder<'_, D>,
12620 offset: usize,
12621 _depth: fidl::encoding::Depth,
12622 ) -> fidl::Result<()> {
12623 decoder.debug_check_bounds::<Self>(offset);
12624 fidl::decode!(
12626 StreamOutputFormat,
12627 D,
12628 &mut self.output_format,
12629 decoder,
12630 offset + 0,
12631 _depth
12632 )?;
12633 Ok(())
12634 }
12635 }
12636
12637 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputPacketRequest {
12638 type Borrowed<'a> = &'a Self;
12639 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12640 value
12641 }
12642 }
12643
12644 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputPacketRequest {
12645 type Owned = Self;
12646
12647 #[inline(always)]
12648 fn inline_align(_context: fidl::encoding::Context) -> usize {
12649 8
12650 }
12651
12652 #[inline(always)]
12653 fn inline_size(_context: fidl::encoding::Context) -> usize {
12654 24
12655 }
12656 }
12657
12658 unsafe impl<D: fidl::encoding::ResourceDialect>
12659 fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D>
12660 for &StreamProcessorOnOutputPacketRequest
12661 {
12662 #[inline]
12663 unsafe fn encode(
12664 self,
12665 encoder: &mut fidl::encoding::Encoder<'_, D>,
12666 offset: usize,
12667 _depth: fidl::encoding::Depth,
12668 ) -> fidl::Result<()> {
12669 encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12670 fidl::encoding::Encode::<StreamProcessorOnOutputPacketRequest, D>::encode(
12672 (
12673 <Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.output_packet),
12674 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12675 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_during),
12676 ),
12677 encoder,
12678 offset,
12679 _depth,
12680 )
12681 }
12682 }
12683 unsafe impl<
12684 D: fidl::encoding::ResourceDialect,
12685 T0: fidl::encoding::Encode<Packet, D>,
12686 T1: fidl::encoding::Encode<bool, D>,
12687 T2: fidl::encoding::Encode<bool, D>,
12688 > fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D> for (T0, T1, T2)
12689 {
12690 #[inline]
12691 unsafe fn encode(
12692 self,
12693 encoder: &mut fidl::encoding::Encoder<'_, D>,
12694 offset: usize,
12695 depth: fidl::encoding::Depth,
12696 ) -> fidl::Result<()> {
12697 encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12698 unsafe {
12701 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
12702 (ptr as *mut u64).write_unaligned(0);
12703 }
12704 self.0.encode(encoder, offset + 0, depth)?;
12706 self.1.encode(encoder, offset + 16, depth)?;
12707 self.2.encode(encoder, offset + 17, depth)?;
12708 Ok(())
12709 }
12710 }
12711
12712 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12713 for StreamProcessorOnOutputPacketRequest
12714 {
12715 #[inline(always)]
12716 fn new_empty() -> Self {
12717 Self {
12718 output_packet: fidl::new_empty!(Packet, D),
12719 error_detected_before: fidl::new_empty!(bool, D),
12720 error_detected_during: fidl::new_empty!(bool, D),
12721 }
12722 }
12723
12724 #[inline]
12725 unsafe fn decode(
12726 &mut self,
12727 decoder: &mut fidl::encoding::Decoder<'_, D>,
12728 offset: usize,
12729 _depth: fidl::encoding::Depth,
12730 ) -> fidl::Result<()> {
12731 decoder.debug_check_bounds::<Self>(offset);
12732 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
12734 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12735 let mask = 0xffffffffffff0000u64;
12736 let maskedval = padval & mask;
12737 if maskedval != 0 {
12738 return Err(fidl::Error::NonZeroPadding {
12739 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
12740 });
12741 }
12742 fidl::decode!(Packet, D, &mut self.output_packet, decoder, offset + 0, _depth)?;
12743 fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 16, _depth)?;
12744 fidl::decode!(bool, D, &mut self.error_detected_during, decoder, offset + 17, _depth)?;
12745 Ok(())
12746 }
12747 }
12748
12749 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnStreamFailedRequest {
12750 type Borrowed<'a> = &'a Self;
12751 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12752 value
12753 }
12754 }
12755
12756 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnStreamFailedRequest {
12757 type Owned = Self;
12758
12759 #[inline(always)]
12760 fn inline_align(_context: fidl::encoding::Context) -> usize {
12761 8
12762 }
12763
12764 #[inline(always)]
12765 fn inline_size(_context: fidl::encoding::Context) -> usize {
12766 16
12767 }
12768 }
12769
12770 unsafe impl<D: fidl::encoding::ResourceDialect>
12771 fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D>
12772 for &StreamProcessorOnStreamFailedRequest
12773 {
12774 #[inline]
12775 unsafe fn encode(
12776 self,
12777 encoder: &mut fidl::encoding::Encoder<'_, D>,
12778 offset: usize,
12779 _depth: fidl::encoding::Depth,
12780 ) -> fidl::Result<()> {
12781 encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12782 fidl::encoding::Encode::<StreamProcessorOnStreamFailedRequest, D>::encode(
12784 (
12785 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12786 <StreamError as fidl::encoding::ValueTypeMarker>::borrow(&self.error),
12787 ),
12788 encoder,
12789 offset,
12790 _depth,
12791 )
12792 }
12793 }
12794 unsafe impl<
12795 D: fidl::encoding::ResourceDialect,
12796 T0: fidl::encoding::Encode<u64, D>,
12797 T1: fidl::encoding::Encode<StreamError, D>,
12798 > fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D> for (T0, T1)
12799 {
12800 #[inline]
12801 unsafe fn encode(
12802 self,
12803 encoder: &mut fidl::encoding::Encoder<'_, D>,
12804 offset: usize,
12805 depth: fidl::encoding::Depth,
12806 ) -> fidl::Result<()> {
12807 encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12808 unsafe {
12811 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12812 (ptr as *mut u64).write_unaligned(0);
12813 }
12814 self.0.encode(encoder, offset + 0, depth)?;
12816 self.1.encode(encoder, offset + 8, depth)?;
12817 Ok(())
12818 }
12819 }
12820
12821 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12822 for StreamProcessorOnStreamFailedRequest
12823 {
12824 #[inline(always)]
12825 fn new_empty() -> Self {
12826 Self {
12827 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12828 error: fidl::new_empty!(StreamError, D),
12829 }
12830 }
12831
12832 #[inline]
12833 unsafe fn decode(
12834 &mut self,
12835 decoder: &mut fidl::encoding::Decoder<'_, D>,
12836 offset: usize,
12837 _depth: fidl::encoding::Depth,
12838 ) -> fidl::Result<()> {
12839 decoder.debug_check_bounds::<Self>(offset);
12840 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12842 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12843 let mask = 0xffffffff00000000u64;
12844 let maskedval = padval & mask;
12845 if maskedval != 0 {
12846 return Err(fidl::Error::NonZeroPadding {
12847 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12848 });
12849 }
12850 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12851 fidl::decode!(StreamError, D, &mut self.error, decoder, offset + 8, _depth)?;
12852 Ok(())
12853 }
12854 }
12855
12856 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12857 type Borrowed<'a> = &'a Self;
12858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12859 value
12860 }
12861 }
12862
12863 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12864 type Owned = Self;
12865
12866 #[inline(always)]
12867 fn inline_align(_context: fidl::encoding::Context) -> usize {
12868 8
12869 }
12870
12871 #[inline(always)]
12872 fn inline_size(_context: fidl::encoding::Context) -> usize {
12873 8
12874 }
12875 #[inline(always)]
12876 fn encode_is_copy() -> bool {
12877 true
12878 }
12879
12880 #[inline(always)]
12881 fn decode_is_copy() -> bool {
12882 true
12883 }
12884 }
12885
12886 unsafe impl<D: fidl::encoding::ResourceDialect>
12887 fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D>
12888 for &StreamProcessorQueueInputEndOfStreamRequest
12889 {
12890 #[inline]
12891 unsafe fn encode(
12892 self,
12893 encoder: &mut fidl::encoding::Encoder<'_, D>,
12894 offset: usize,
12895 _depth: fidl::encoding::Depth,
12896 ) -> fidl::Result<()> {
12897 encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12898 unsafe {
12899 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12901 (buf_ptr as *mut StreamProcessorQueueInputEndOfStreamRequest).write_unaligned(
12902 (self as *const StreamProcessorQueueInputEndOfStreamRequest).read(),
12903 );
12904 }
12907 Ok(())
12908 }
12909 }
12910 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12911 fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D> for (T0,)
12912 {
12913 #[inline]
12914 unsafe fn encode(
12915 self,
12916 encoder: &mut fidl::encoding::Encoder<'_, D>,
12917 offset: usize,
12918 depth: fidl::encoding::Depth,
12919 ) -> fidl::Result<()> {
12920 encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12921 self.0.encode(encoder, offset + 0, depth)?;
12925 Ok(())
12926 }
12927 }
12928
12929 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12930 for StreamProcessorQueueInputEndOfStreamRequest
12931 {
12932 #[inline(always)]
12933 fn new_empty() -> Self {
12934 Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
12935 }
12936
12937 #[inline]
12938 unsafe fn decode(
12939 &mut self,
12940 decoder: &mut fidl::encoding::Decoder<'_, D>,
12941 offset: usize,
12942 _depth: fidl::encoding::Depth,
12943 ) -> fidl::Result<()> {
12944 decoder.debug_check_bounds::<Self>(offset);
12945 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12946 unsafe {
12949 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12950 }
12951 Ok(())
12952 }
12953 }
12954
12955 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12956 type Borrowed<'a> = &'a Self;
12957 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12958 value
12959 }
12960 }
12961
12962 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12963 type Owned = Self;
12964
12965 #[inline(always)]
12966 fn inline_align(_context: fidl::encoding::Context) -> usize {
12967 8
12968 }
12969
12970 #[inline(always)]
12971 fn inline_size(_context: fidl::encoding::Context) -> usize {
12972 24
12973 }
12974 }
12975
12976 unsafe impl<D: fidl::encoding::ResourceDialect>
12977 fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D>
12978 for &StreamProcessorQueueInputFormatDetailsRequest
12979 {
12980 #[inline]
12981 unsafe fn encode(
12982 self,
12983 encoder: &mut fidl::encoding::Encoder<'_, D>,
12984 offset: usize,
12985 _depth: fidl::encoding::Depth,
12986 ) -> fidl::Result<()> {
12987 encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
12988 fidl::encoding::Encode::<StreamProcessorQueueInputFormatDetailsRequest, D>::encode(
12990 (
12991 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12992 <FormatDetails as fidl::encoding::ValueTypeMarker>::borrow(
12993 &self.format_details,
12994 ),
12995 ),
12996 encoder,
12997 offset,
12998 _depth,
12999 )
13000 }
13001 }
13002 unsafe impl<
13003 D: fidl::encoding::ResourceDialect,
13004 T0: fidl::encoding::Encode<u64, D>,
13005 T1: fidl::encoding::Encode<FormatDetails, D>,
13006 > fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D> for (T0, T1)
13007 {
13008 #[inline]
13009 unsafe fn encode(
13010 self,
13011 encoder: &mut fidl::encoding::Encoder<'_, D>,
13012 offset: usize,
13013 depth: fidl::encoding::Depth,
13014 ) -> fidl::Result<()> {
13015 encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
13016 self.0.encode(encoder, offset + 0, depth)?;
13020 self.1.encode(encoder, offset + 8, depth)?;
13021 Ok(())
13022 }
13023 }
13024
13025 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13026 for StreamProcessorQueueInputFormatDetailsRequest
13027 {
13028 #[inline(always)]
13029 fn new_empty() -> Self {
13030 Self {
13031 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
13032 format_details: fidl::new_empty!(FormatDetails, D),
13033 }
13034 }
13035
13036 #[inline]
13037 unsafe fn decode(
13038 &mut self,
13039 decoder: &mut fidl::encoding::Decoder<'_, D>,
13040 offset: usize,
13041 _depth: fidl::encoding::Depth,
13042 ) -> fidl::Result<()> {
13043 decoder.debug_check_bounds::<Self>(offset);
13044 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
13046 fidl::decode!(FormatDetails, D, &mut self.format_details, decoder, offset + 8, _depth)?;
13047 Ok(())
13048 }
13049 }
13050
13051 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputPacketRequest {
13052 type Borrowed<'a> = &'a Self;
13053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13054 value
13055 }
13056 }
13057
13058 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputPacketRequest {
13059 type Owned = Self;
13060
13061 #[inline(always)]
13062 fn inline_align(_context: fidl::encoding::Context) -> usize {
13063 8
13064 }
13065
13066 #[inline(always)]
13067 fn inline_size(_context: fidl::encoding::Context) -> usize {
13068 16
13069 }
13070 }
13071
13072 unsafe impl<D: fidl::encoding::ResourceDialect>
13073 fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D>
13074 for &StreamProcessorQueueInputPacketRequest
13075 {
13076 #[inline]
13077 unsafe fn encode(
13078 self,
13079 encoder: &mut fidl::encoding::Encoder<'_, D>,
13080 offset: usize,
13081 _depth: fidl::encoding::Depth,
13082 ) -> fidl::Result<()> {
13083 encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
13084 fidl::encoding::Encode::<StreamProcessorQueueInputPacketRequest, D>::encode(
13086 (<Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.packet),),
13087 encoder,
13088 offset,
13089 _depth,
13090 )
13091 }
13092 }
13093 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Packet, D>>
13094 fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D> for (T0,)
13095 {
13096 #[inline]
13097 unsafe fn encode(
13098 self,
13099 encoder: &mut fidl::encoding::Encoder<'_, D>,
13100 offset: usize,
13101 depth: fidl::encoding::Depth,
13102 ) -> fidl::Result<()> {
13103 encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
13104 self.0.encode(encoder, offset + 0, depth)?;
13108 Ok(())
13109 }
13110 }
13111
13112 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13113 for StreamProcessorQueueInputPacketRequest
13114 {
13115 #[inline(always)]
13116 fn new_empty() -> Self {
13117 Self { packet: fidl::new_empty!(Packet, D) }
13118 }
13119
13120 #[inline]
13121 unsafe fn decode(
13122 &mut self,
13123 decoder: &mut fidl::encoding::Decoder<'_, D>,
13124 offset: usize,
13125 _depth: fidl::encoding::Depth,
13126 ) -> fidl::Result<()> {
13127 decoder.debug_check_bounds::<Self>(offset);
13128 fidl::decode!(Packet, D, &mut self.packet, decoder, offset + 0, _depth)?;
13130 Ok(())
13131 }
13132 }
13133
13134 impl fidl::encoding::ValueTypeMarker for StreamProcessorRecycleOutputPacketRequest {
13135 type Borrowed<'a> = &'a Self;
13136 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13137 value
13138 }
13139 }
13140
13141 unsafe impl fidl::encoding::TypeMarker for StreamProcessorRecycleOutputPacketRequest {
13142 type Owned = Self;
13143
13144 #[inline(always)]
13145 fn inline_align(_context: fidl::encoding::Context) -> usize {
13146 8
13147 }
13148
13149 #[inline(always)]
13150 fn inline_size(_context: fidl::encoding::Context) -> usize {
13151 16
13152 }
13153 }
13154
13155 unsafe impl<D: fidl::encoding::ResourceDialect>
13156 fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D>
13157 for &StreamProcessorRecycleOutputPacketRequest
13158 {
13159 #[inline]
13160 unsafe fn encode(
13161 self,
13162 encoder: &mut fidl::encoding::Encoder<'_, D>,
13163 offset: usize,
13164 _depth: fidl::encoding::Depth,
13165 ) -> fidl::Result<()> {
13166 encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
13167 fidl::encoding::Encode::<StreamProcessorRecycleOutputPacketRequest, D>::encode(
13169 (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
13170 &self.available_output_packet,
13171 ),),
13172 encoder,
13173 offset,
13174 _depth,
13175 )
13176 }
13177 }
13178 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
13179 fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D> for (T0,)
13180 {
13181 #[inline]
13182 unsafe fn encode(
13183 self,
13184 encoder: &mut fidl::encoding::Encoder<'_, D>,
13185 offset: usize,
13186 depth: fidl::encoding::Depth,
13187 ) -> fidl::Result<()> {
13188 encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
13189 self.0.encode(encoder, offset + 0, depth)?;
13193 Ok(())
13194 }
13195 }
13196
13197 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13198 for StreamProcessorRecycleOutputPacketRequest
13199 {
13200 #[inline(always)]
13201 fn new_empty() -> Self {
13202 Self { available_output_packet: fidl::new_empty!(PacketHeader, D) }
13203 }
13204
13205 #[inline]
13206 unsafe fn decode(
13207 &mut self,
13208 decoder: &mut fidl::encoding::Decoder<'_, D>,
13209 offset: usize,
13210 _depth: fidl::encoding::Depth,
13211 ) -> fidl::Result<()> {
13212 decoder.debug_check_bounds::<Self>(offset);
13213 fidl::decode!(
13215 PacketHeader,
13216 D,
13217 &mut self.available_output_packet,
13218 decoder,
13219 offset + 0,
13220 _depth
13221 )?;
13222 Ok(())
13223 }
13224 }
13225
13226 impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketNoReplyRequest {
13227 type Borrowed<'a> = &'a Self;
13228 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13229 value
13230 }
13231 }
13232
13233 unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketNoReplyRequest {
13234 type Owned = Self;
13235
13236 #[inline(always)]
13237 fn inline_align(_context: fidl::encoding::Context) -> usize {
13238 8
13239 }
13240
13241 #[inline(always)]
13242 fn inline_size(_context: fidl::encoding::Context) -> usize {
13243 56
13244 }
13245 }
13246
13247 unsafe impl<D: fidl::encoding::ResourceDialect>
13248 fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D>
13249 for &StreamSinkSendPacketNoReplyRequest
13250 {
13251 #[inline]
13252 unsafe fn encode(
13253 self,
13254 encoder: &mut fidl::encoding::Encoder<'_, D>,
13255 offset: usize,
13256 _depth: fidl::encoding::Depth,
13257 ) -> fidl::Result<()> {
13258 encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13259 unsafe {
13260 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13262 (buf_ptr as *mut StreamSinkSendPacketNoReplyRequest)
13263 .write_unaligned((self as *const StreamSinkSendPacketNoReplyRequest).read());
13264 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13267 let padding_mask = 0xffffffff00000000u64;
13268 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13269 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13270 let padding_mask = 0xffffffff00000000u64;
13271 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13272 }
13273 Ok(())
13274 }
13275 }
13276 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13277 fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D> for (T0,)
13278 {
13279 #[inline]
13280 unsafe fn encode(
13281 self,
13282 encoder: &mut fidl::encoding::Encoder<'_, D>,
13283 offset: usize,
13284 depth: fidl::encoding::Depth,
13285 ) -> fidl::Result<()> {
13286 encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13287 self.0.encode(encoder, offset + 0, depth)?;
13291 Ok(())
13292 }
13293 }
13294
13295 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13296 for StreamSinkSendPacketNoReplyRequest
13297 {
13298 #[inline(always)]
13299 fn new_empty() -> Self {
13300 Self { packet: fidl::new_empty!(StreamPacket, D) }
13301 }
13302
13303 #[inline]
13304 unsafe fn decode(
13305 &mut self,
13306 decoder: &mut fidl::encoding::Decoder<'_, D>,
13307 offset: usize,
13308 _depth: fidl::encoding::Depth,
13309 ) -> fidl::Result<()> {
13310 decoder.debug_check_bounds::<Self>(offset);
13311 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13312 let ptr = unsafe { buf_ptr.offset(8) };
13314 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13315 let mask = 0xffffffff00000000u64;
13316 let maskedval = padval & mask;
13317 if maskedval != 0 {
13318 return Err(fidl::Error::NonZeroPadding {
13319 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13320 });
13321 }
13322 let ptr = unsafe { buf_ptr.offset(32) };
13323 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13324 let mask = 0xffffffff00000000u64;
13325 let maskedval = padval & mask;
13326 if maskedval != 0 {
13327 return Err(fidl::Error::NonZeroPadding {
13328 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13329 });
13330 }
13331 unsafe {
13333 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13334 }
13335 Ok(())
13336 }
13337 }
13338
13339 impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketRequest {
13340 type Borrowed<'a> = &'a Self;
13341 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13342 value
13343 }
13344 }
13345
13346 unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketRequest {
13347 type Owned = Self;
13348
13349 #[inline(always)]
13350 fn inline_align(_context: fidl::encoding::Context) -> usize {
13351 8
13352 }
13353
13354 #[inline(always)]
13355 fn inline_size(_context: fidl::encoding::Context) -> usize {
13356 56
13357 }
13358 }
13359
13360 unsafe impl<D: fidl::encoding::ResourceDialect>
13361 fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for &StreamSinkSendPacketRequest
13362 {
13363 #[inline]
13364 unsafe fn encode(
13365 self,
13366 encoder: &mut fidl::encoding::Encoder<'_, D>,
13367 offset: usize,
13368 _depth: fidl::encoding::Depth,
13369 ) -> fidl::Result<()> {
13370 encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13371 unsafe {
13372 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13374 (buf_ptr as *mut StreamSinkSendPacketRequest)
13375 .write_unaligned((self as *const StreamSinkSendPacketRequest).read());
13376 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13379 let padding_mask = 0xffffffff00000000u64;
13380 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13381 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13382 let padding_mask = 0xffffffff00000000u64;
13383 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13384 }
13385 Ok(())
13386 }
13387 }
13388 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13389 fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for (T0,)
13390 {
13391 #[inline]
13392 unsafe fn encode(
13393 self,
13394 encoder: &mut fidl::encoding::Encoder<'_, D>,
13395 offset: usize,
13396 depth: fidl::encoding::Depth,
13397 ) -> fidl::Result<()> {
13398 encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13399 self.0.encode(encoder, offset + 0, depth)?;
13403 Ok(())
13404 }
13405 }
13406
13407 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13408 for StreamSinkSendPacketRequest
13409 {
13410 #[inline(always)]
13411 fn new_empty() -> Self {
13412 Self { packet: fidl::new_empty!(StreamPacket, D) }
13413 }
13414
13415 #[inline]
13416 unsafe fn decode(
13417 &mut self,
13418 decoder: &mut fidl::encoding::Decoder<'_, D>,
13419 offset: usize,
13420 _depth: fidl::encoding::Depth,
13421 ) -> fidl::Result<()> {
13422 decoder.debug_check_bounds::<Self>(offset);
13423 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13424 let ptr = unsafe { buf_ptr.offset(8) };
13426 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13427 let mask = 0xffffffff00000000u64;
13428 let maskedval = padval & mask;
13429 if maskedval != 0 {
13430 return Err(fidl::Error::NonZeroPadding {
13431 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13432 });
13433 }
13434 let ptr = unsafe { buf_ptr.offset(32) };
13435 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13436 let mask = 0xffffffff00000000u64;
13437 let maskedval = padval & mask;
13438 if maskedval != 0 {
13439 return Err(fidl::Error::NonZeroPadding {
13440 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13441 });
13442 }
13443 unsafe {
13445 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13446 }
13447 Ok(())
13448 }
13449 }
13450
13451 impl fidl::encoding::ValueTypeMarker for StreamSourceOnPacketProducedRequest {
13452 type Borrowed<'a> = &'a Self;
13453 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13454 value
13455 }
13456 }
13457
13458 unsafe impl fidl::encoding::TypeMarker for StreamSourceOnPacketProducedRequest {
13459 type Owned = Self;
13460
13461 #[inline(always)]
13462 fn inline_align(_context: fidl::encoding::Context) -> usize {
13463 8
13464 }
13465
13466 #[inline(always)]
13467 fn inline_size(_context: fidl::encoding::Context) -> usize {
13468 56
13469 }
13470 }
13471
13472 unsafe impl<D: fidl::encoding::ResourceDialect>
13473 fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D>
13474 for &StreamSourceOnPacketProducedRequest
13475 {
13476 #[inline]
13477 unsafe fn encode(
13478 self,
13479 encoder: &mut fidl::encoding::Encoder<'_, D>,
13480 offset: usize,
13481 _depth: fidl::encoding::Depth,
13482 ) -> fidl::Result<()> {
13483 encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13484 unsafe {
13485 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13487 (buf_ptr as *mut StreamSourceOnPacketProducedRequest)
13488 .write_unaligned((self as *const StreamSourceOnPacketProducedRequest).read());
13489 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13492 let padding_mask = 0xffffffff00000000u64;
13493 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13494 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13495 let padding_mask = 0xffffffff00000000u64;
13496 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13497 }
13498 Ok(())
13499 }
13500 }
13501 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13502 fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D> for (T0,)
13503 {
13504 #[inline]
13505 unsafe fn encode(
13506 self,
13507 encoder: &mut fidl::encoding::Encoder<'_, D>,
13508 offset: usize,
13509 depth: fidl::encoding::Depth,
13510 ) -> fidl::Result<()> {
13511 encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13512 self.0.encode(encoder, offset + 0, depth)?;
13516 Ok(())
13517 }
13518 }
13519
13520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13521 for StreamSourceOnPacketProducedRequest
13522 {
13523 #[inline(always)]
13524 fn new_empty() -> Self {
13525 Self { packet: fidl::new_empty!(StreamPacket, D) }
13526 }
13527
13528 #[inline]
13529 unsafe fn decode(
13530 &mut self,
13531 decoder: &mut fidl::encoding::Decoder<'_, D>,
13532 offset: usize,
13533 _depth: fidl::encoding::Depth,
13534 ) -> fidl::Result<()> {
13535 decoder.debug_check_bounds::<Self>(offset);
13536 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13537 let ptr = unsafe { buf_ptr.offset(8) };
13539 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13540 let mask = 0xffffffff00000000u64;
13541 let maskedval = padval & mask;
13542 if maskedval != 0 {
13543 return Err(fidl::Error::NonZeroPadding {
13544 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13545 });
13546 }
13547 let ptr = unsafe { buf_ptr.offset(32) };
13548 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13549 let mask = 0xffffffff00000000u64;
13550 let maskedval = padval & mask;
13551 if maskedval != 0 {
13552 return Err(fidl::Error::NonZeroPadding {
13553 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13554 });
13555 }
13556 unsafe {
13558 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13559 }
13560 Ok(())
13561 }
13562 }
13563
13564 impl fidl::encoding::ValueTypeMarker for StreamSourceReleasePacketRequest {
13565 type Borrowed<'a> = &'a Self;
13566 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13567 value
13568 }
13569 }
13570
13571 unsafe impl fidl::encoding::TypeMarker for StreamSourceReleasePacketRequest {
13572 type Owned = Self;
13573
13574 #[inline(always)]
13575 fn inline_align(_context: fidl::encoding::Context) -> usize {
13576 8
13577 }
13578
13579 #[inline(always)]
13580 fn inline_size(_context: fidl::encoding::Context) -> usize {
13581 56
13582 }
13583 }
13584
13585 unsafe impl<D: fidl::encoding::ResourceDialect>
13586 fidl::encoding::Encode<StreamSourceReleasePacketRequest, D>
13587 for &StreamSourceReleasePacketRequest
13588 {
13589 #[inline]
13590 unsafe fn encode(
13591 self,
13592 encoder: &mut fidl::encoding::Encoder<'_, D>,
13593 offset: usize,
13594 _depth: fidl::encoding::Depth,
13595 ) -> fidl::Result<()> {
13596 encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13597 unsafe {
13598 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13600 (buf_ptr as *mut StreamSourceReleasePacketRequest)
13601 .write_unaligned((self as *const StreamSourceReleasePacketRequest).read());
13602 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13605 let padding_mask = 0xffffffff00000000u64;
13606 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13607 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13608 let padding_mask = 0xffffffff00000000u64;
13609 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13610 }
13611 Ok(())
13612 }
13613 }
13614 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13615 fidl::encoding::Encode<StreamSourceReleasePacketRequest, D> for (T0,)
13616 {
13617 #[inline]
13618 unsafe fn encode(
13619 self,
13620 encoder: &mut fidl::encoding::Encoder<'_, D>,
13621 offset: usize,
13622 depth: fidl::encoding::Depth,
13623 ) -> fidl::Result<()> {
13624 encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13625 self.0.encode(encoder, offset + 0, depth)?;
13629 Ok(())
13630 }
13631 }
13632
13633 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13634 for StreamSourceReleasePacketRequest
13635 {
13636 #[inline(always)]
13637 fn new_empty() -> Self {
13638 Self { packet: fidl::new_empty!(StreamPacket, D) }
13639 }
13640
13641 #[inline]
13642 unsafe fn decode(
13643 &mut self,
13644 decoder: &mut fidl::encoding::Decoder<'_, D>,
13645 offset: usize,
13646 _depth: fidl::encoding::Depth,
13647 ) -> fidl::Result<()> {
13648 decoder.debug_check_bounds::<Self>(offset);
13649 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13650 let ptr = unsafe { buf_ptr.offset(8) };
13652 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13653 let mask = 0xffffffff00000000u64;
13654 let maskedval = padval & mask;
13655 if maskedval != 0 {
13656 return Err(fidl::Error::NonZeroPadding {
13657 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13658 });
13659 }
13660 let ptr = unsafe { buf_ptr.offset(32) };
13661 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13662 let mask = 0xffffffff00000000u64;
13663 let maskedval = padval & mask;
13664 if maskedval != 0 {
13665 return Err(fidl::Error::NonZeroPadding {
13666 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13667 });
13668 }
13669 unsafe {
13671 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13672 }
13673 Ok(())
13674 }
13675 }
13676
13677 impl fidl::encoding::ValueTypeMarker for StreamType {
13678 type Borrowed<'a> = &'a Self;
13679 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13680 value
13681 }
13682 }
13683
13684 unsafe impl fidl::encoding::TypeMarker for StreamType {
13685 type Owned = Self;
13686
13687 #[inline(always)]
13688 fn inline_align(_context: fidl::encoding::Context) -> usize {
13689 8
13690 }
13691
13692 #[inline(always)]
13693 fn inline_size(_context: fidl::encoding::Context) -> usize {
13694 48
13695 }
13696 }
13697
13698 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamType, D>
13699 for &StreamType
13700 {
13701 #[inline]
13702 unsafe fn encode(
13703 self,
13704 encoder: &mut fidl::encoding::Encoder<'_, D>,
13705 offset: usize,
13706 _depth: fidl::encoding::Depth,
13707 ) -> fidl::Result<()> {
13708 encoder.debug_check_bounds::<StreamType>(offset);
13709 fidl::encoding::Encode::<StreamType, D>::encode(
13711 (
13712 <MediumSpecificStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.medium_specific),
13713 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding),
13714 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding_parameters),
13715 ),
13716 encoder, offset, _depth
13717 )
13718 }
13719 }
13720 unsafe impl<
13721 D: fidl::encoding::ResourceDialect,
13722 T0: fidl::encoding::Encode<MediumSpecificStreamType, D>,
13723 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
13724 T2: fidl::encoding::Encode<
13725 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13726 D,
13727 >,
13728 > fidl::encoding::Encode<StreamType, D> for (T0, T1, T2)
13729 {
13730 #[inline]
13731 unsafe fn encode(
13732 self,
13733 encoder: &mut fidl::encoding::Encoder<'_, D>,
13734 offset: usize,
13735 depth: fidl::encoding::Depth,
13736 ) -> fidl::Result<()> {
13737 encoder.debug_check_bounds::<StreamType>(offset);
13738 self.0.encode(encoder, offset + 0, depth)?;
13742 self.1.encode(encoder, offset + 16, depth)?;
13743 self.2.encode(encoder, offset + 32, depth)?;
13744 Ok(())
13745 }
13746 }
13747
13748 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamType {
13749 #[inline(always)]
13750 fn new_empty() -> Self {
13751 Self {
13752 medium_specific: fidl::new_empty!(MediumSpecificStreamType, D),
13753 encoding: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
13754 encoding_parameters: fidl::new_empty!(
13755 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13756 D
13757 ),
13758 }
13759 }
13760
13761 #[inline]
13762 unsafe fn decode(
13763 &mut self,
13764 decoder: &mut fidl::encoding::Decoder<'_, D>,
13765 offset: usize,
13766 _depth: fidl::encoding::Depth,
13767 ) -> fidl::Result<()> {
13768 decoder.debug_check_bounds::<Self>(offset);
13769 fidl::decode!(
13771 MediumSpecificStreamType,
13772 D,
13773 &mut self.medium_specific,
13774 decoder,
13775 offset + 0,
13776 _depth
13777 )?;
13778 fidl::decode!(
13779 fidl::encoding::BoundedString<255>,
13780 D,
13781 &mut self.encoding,
13782 decoder,
13783 offset + 16,
13784 _depth
13785 )?;
13786 fidl::decode!(
13787 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13788 D,
13789 &mut self.encoding_parameters,
13790 decoder,
13791 offset + 32,
13792 _depth
13793 )?;
13794 Ok(())
13795 }
13796 }
13797
13798 impl fidl::encoding::ValueTypeMarker for SubpictureStreamType {
13799 type Borrowed<'a> = &'a Self;
13800 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13801 value
13802 }
13803 }
13804
13805 unsafe impl fidl::encoding::TypeMarker for SubpictureStreamType {
13806 type Owned = Self;
13807
13808 #[inline(always)]
13809 fn inline_align(_context: fidl::encoding::Context) -> usize {
13810 1
13811 }
13812
13813 #[inline(always)]
13814 fn inline_size(_context: fidl::encoding::Context) -> usize {
13815 1
13816 }
13817 }
13818
13819 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubpictureStreamType, D>
13820 for &SubpictureStreamType
13821 {
13822 #[inline]
13823 unsafe fn encode(
13824 self,
13825 encoder: &mut fidl::encoding::Encoder<'_, D>,
13826 offset: usize,
13827 _depth: fidl::encoding::Depth,
13828 ) -> fidl::Result<()> {
13829 encoder.debug_check_bounds::<SubpictureStreamType>(offset);
13830 encoder.write_num(0u8, offset);
13831 Ok(())
13832 }
13833 }
13834
13835 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubpictureStreamType {
13836 #[inline(always)]
13837 fn new_empty() -> Self {
13838 Self
13839 }
13840
13841 #[inline]
13842 unsafe fn decode(
13843 &mut self,
13844 decoder: &mut fidl::encoding::Decoder<'_, D>,
13845 offset: usize,
13846 _depth: fidl::encoding::Depth,
13847 ) -> fidl::Result<()> {
13848 decoder.debug_check_bounds::<Self>(offset);
13849 match decoder.read_num::<u8>(offset) {
13850 0 => Ok(()),
13851 _ => Err(fidl::Error::Invalid),
13852 }
13853 }
13854 }
13855
13856 impl fidl::encoding::ValueTypeMarker for SubsampleEntry {
13857 type Borrowed<'a> = &'a Self;
13858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13859 value
13860 }
13861 }
13862
13863 unsafe impl fidl::encoding::TypeMarker for SubsampleEntry {
13864 type Owned = Self;
13865
13866 #[inline(always)]
13867 fn inline_align(_context: fidl::encoding::Context) -> usize {
13868 4
13869 }
13870
13871 #[inline(always)]
13872 fn inline_size(_context: fidl::encoding::Context) -> usize {
13873 8
13874 }
13875 #[inline(always)]
13876 fn encode_is_copy() -> bool {
13877 true
13878 }
13879
13880 #[inline(always)]
13881 fn decode_is_copy() -> bool {
13882 true
13883 }
13884 }
13885
13886 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubsampleEntry, D>
13887 for &SubsampleEntry
13888 {
13889 #[inline]
13890 unsafe fn encode(
13891 self,
13892 encoder: &mut fidl::encoding::Encoder<'_, D>,
13893 offset: usize,
13894 _depth: fidl::encoding::Depth,
13895 ) -> fidl::Result<()> {
13896 encoder.debug_check_bounds::<SubsampleEntry>(offset);
13897 unsafe {
13898 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13900 (buf_ptr as *mut SubsampleEntry)
13901 .write_unaligned((self as *const SubsampleEntry).read());
13902 }
13905 Ok(())
13906 }
13907 }
13908 unsafe impl<
13909 D: fidl::encoding::ResourceDialect,
13910 T0: fidl::encoding::Encode<u32, D>,
13911 T1: fidl::encoding::Encode<u32, D>,
13912 > fidl::encoding::Encode<SubsampleEntry, D> for (T0, T1)
13913 {
13914 #[inline]
13915 unsafe fn encode(
13916 self,
13917 encoder: &mut fidl::encoding::Encoder<'_, D>,
13918 offset: usize,
13919 depth: fidl::encoding::Depth,
13920 ) -> fidl::Result<()> {
13921 encoder.debug_check_bounds::<SubsampleEntry>(offset);
13922 self.0.encode(encoder, offset + 0, depth)?;
13926 self.1.encode(encoder, offset + 4, depth)?;
13927 Ok(())
13928 }
13929 }
13930
13931 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubsampleEntry {
13932 #[inline(always)]
13933 fn new_empty() -> Self {
13934 Self {
13935 clear_bytes: fidl::new_empty!(u32, D),
13936 encrypted_bytes: fidl::new_empty!(u32, D),
13937 }
13938 }
13939
13940 #[inline]
13941 unsafe fn decode(
13942 &mut self,
13943 decoder: &mut fidl::encoding::Decoder<'_, D>,
13944 offset: usize,
13945 _depth: fidl::encoding::Depth,
13946 ) -> fidl::Result<()> {
13947 decoder.debug_check_bounds::<Self>(offset);
13948 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13949 unsafe {
13952 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
13953 }
13954 Ok(())
13955 }
13956 }
13957
13958 impl fidl::encoding::ValueTypeMarker for TextStreamType {
13959 type Borrowed<'a> = &'a Self;
13960 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13961 value
13962 }
13963 }
13964
13965 unsafe impl fidl::encoding::TypeMarker for TextStreamType {
13966 type Owned = Self;
13967
13968 #[inline(always)]
13969 fn inline_align(_context: fidl::encoding::Context) -> usize {
13970 1
13971 }
13972
13973 #[inline(always)]
13974 fn inline_size(_context: fidl::encoding::Context) -> usize {
13975 1
13976 }
13977 }
13978
13979 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TextStreamType, D>
13980 for &TextStreamType
13981 {
13982 #[inline]
13983 unsafe fn encode(
13984 self,
13985 encoder: &mut fidl::encoding::Encoder<'_, D>,
13986 offset: usize,
13987 _depth: fidl::encoding::Depth,
13988 ) -> fidl::Result<()> {
13989 encoder.debug_check_bounds::<TextStreamType>(offset);
13990 encoder.write_num(0u8, offset);
13991 Ok(())
13992 }
13993 }
13994
13995 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TextStreamType {
13996 #[inline(always)]
13997 fn new_empty() -> Self {
13998 Self
13999 }
14000
14001 #[inline]
14002 unsafe fn decode(
14003 &mut self,
14004 decoder: &mut fidl::encoding::Decoder<'_, D>,
14005 offset: usize,
14006 _depth: fidl::encoding::Depth,
14007 ) -> fidl::Result<()> {
14008 decoder.debug_check_bounds::<Self>(offset);
14009 match decoder.read_num::<u8>(offset) {
14010 0 => Ok(()),
14011 _ => Err(fidl::Error::Invalid),
14012 }
14013 }
14014 }
14015
14016 impl fidl::encoding::ValueTypeMarker for TimelineFunction {
14017 type Borrowed<'a> = &'a Self;
14018 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14019 value
14020 }
14021 }
14022
14023 unsafe impl fidl::encoding::TypeMarker for TimelineFunction {
14024 type Owned = Self;
14025
14026 #[inline(always)]
14027 fn inline_align(_context: fidl::encoding::Context) -> usize {
14028 8
14029 }
14030
14031 #[inline(always)]
14032 fn inline_size(_context: fidl::encoding::Context) -> usize {
14033 24
14034 }
14035 #[inline(always)]
14036 fn encode_is_copy() -> bool {
14037 true
14038 }
14039
14040 #[inline(always)]
14041 fn decode_is_copy() -> bool {
14042 true
14043 }
14044 }
14045
14046 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TimelineFunction, D>
14047 for &TimelineFunction
14048 {
14049 #[inline]
14050 unsafe fn encode(
14051 self,
14052 encoder: &mut fidl::encoding::Encoder<'_, D>,
14053 offset: usize,
14054 _depth: fidl::encoding::Depth,
14055 ) -> fidl::Result<()> {
14056 encoder.debug_check_bounds::<TimelineFunction>(offset);
14057 unsafe {
14058 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
14060 (buf_ptr as *mut TimelineFunction)
14061 .write_unaligned((self as *const TimelineFunction).read());
14062 }
14065 Ok(())
14066 }
14067 }
14068 unsafe impl<
14069 D: fidl::encoding::ResourceDialect,
14070 T0: fidl::encoding::Encode<i64, D>,
14071 T1: fidl::encoding::Encode<i64, D>,
14072 T2: fidl::encoding::Encode<u32, D>,
14073 T3: fidl::encoding::Encode<u32, D>,
14074 > fidl::encoding::Encode<TimelineFunction, D> for (T0, T1, T2, T3)
14075 {
14076 #[inline]
14077 unsafe fn encode(
14078 self,
14079 encoder: &mut fidl::encoding::Encoder<'_, D>,
14080 offset: usize,
14081 depth: fidl::encoding::Depth,
14082 ) -> fidl::Result<()> {
14083 encoder.debug_check_bounds::<TimelineFunction>(offset);
14084 self.0.encode(encoder, offset + 0, depth)?;
14088 self.1.encode(encoder, offset + 8, depth)?;
14089 self.2.encode(encoder, offset + 16, depth)?;
14090 self.3.encode(encoder, offset + 20, depth)?;
14091 Ok(())
14092 }
14093 }
14094
14095 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TimelineFunction {
14096 #[inline(always)]
14097 fn new_empty() -> Self {
14098 Self {
14099 subject_time: fidl::new_empty!(i64, D),
14100 reference_time: fidl::new_empty!(i64, D),
14101 subject_delta: fidl::new_empty!(u32, D),
14102 reference_delta: fidl::new_empty!(u32, D),
14103 }
14104 }
14105
14106 #[inline]
14107 unsafe fn decode(
14108 &mut self,
14109 decoder: &mut fidl::encoding::Decoder<'_, D>,
14110 offset: usize,
14111 _depth: fidl::encoding::Depth,
14112 ) -> fidl::Result<()> {
14113 decoder.debug_check_bounds::<Self>(offset);
14114 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
14115 unsafe {
14118 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
14119 }
14120 Ok(())
14121 }
14122 }
14123
14124 impl fidl::encoding::ValueTypeMarker for UsageGainListenerOnGainMuteChangedRequest {
14125 type Borrowed<'a> = &'a Self;
14126 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14127 value
14128 }
14129 }
14130
14131 unsafe impl fidl::encoding::TypeMarker for UsageGainListenerOnGainMuteChangedRequest {
14132 type Owned = Self;
14133
14134 #[inline(always)]
14135 fn inline_align(_context: fidl::encoding::Context) -> usize {
14136 4
14137 }
14138
14139 #[inline(always)]
14140 fn inline_size(_context: fidl::encoding::Context) -> usize {
14141 8
14142 }
14143 }
14144
14145 unsafe impl<D: fidl::encoding::ResourceDialect>
14146 fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D>
14147 for &UsageGainListenerOnGainMuteChangedRequest
14148 {
14149 #[inline]
14150 unsafe fn encode(
14151 self,
14152 encoder: &mut fidl::encoding::Encoder<'_, D>,
14153 offset: usize,
14154 _depth: fidl::encoding::Depth,
14155 ) -> fidl::Result<()> {
14156 encoder.debug_check_bounds::<UsageGainListenerOnGainMuteChangedRequest>(offset);
14157 fidl::encoding::Encode::<UsageGainListenerOnGainMuteChangedRequest, D>::encode(
14159 (
14160 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.muted),
14161 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_dbfs),
14162 ),
14163 encoder,
14164 offset,
14165 _depth,
14166 )
14167 }
14168 }
14169 unsafe impl<
14170 D: fidl::encoding::ResourceDialect,
14171 T0: fidl::encoding::Encode<bool, D>,
14172 T1: fidl::encoding::Encode<f32, D>,
14173 > fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D> for (T0, T1)
14174 {
14175 #[inline]
14176 unsafe fn encode(
14177 self,
14178 encoder: &mut fidl::encoding::Encoder<'_, D>,
14179 offset: usize,
14180 depth: fidl::encoding::Depth,
14181 ) -> fidl::Result<()> {
14182 encoder.debug_check_bounds::<UsageGainListenerOnGainMuteChangedRequest>(offset);
14183 unsafe {
14186 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
14187 (ptr as *mut u32).write_unaligned(0);
14188 }
14189 self.0.encode(encoder, offset + 0, depth)?;
14191 self.1.encode(encoder, offset + 4, depth)?;
14192 Ok(())
14193 }
14194 }
14195
14196 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14197 for UsageGainListenerOnGainMuteChangedRequest
14198 {
14199 #[inline(always)]
14200 fn new_empty() -> Self {
14201 Self { muted: fidl::new_empty!(bool, D), gain_dbfs: fidl::new_empty!(f32, D) }
14202 }
14203
14204 #[inline]
14205 unsafe fn decode(
14206 &mut self,
14207 decoder: &mut fidl::encoding::Decoder<'_, D>,
14208 offset: usize,
14209 _depth: fidl::encoding::Depth,
14210 ) -> fidl::Result<()> {
14211 decoder.debug_check_bounds::<Self>(offset);
14212 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
14214 let padval = unsafe { (ptr as *const u32).read_unaligned() };
14215 let mask = 0xffffff00u32;
14216 let maskedval = padval & mask;
14217 if maskedval != 0 {
14218 return Err(fidl::Error::NonZeroPadding {
14219 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
14220 });
14221 }
14222 fidl::decode!(bool, D, &mut self.muted, decoder, offset + 0, _depth)?;
14223 fidl::decode!(f32, D, &mut self.gain_dbfs, decoder, offset + 4, _depth)?;
14224 Ok(())
14225 }
14226 }
14227
14228 impl fidl::encoding::ValueTypeMarker for UsageWatcher2OnStateChangedRequest {
14229 type Borrowed<'a> = &'a Self;
14230 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14231 value
14232 }
14233 }
14234
14235 unsafe impl fidl::encoding::TypeMarker for UsageWatcher2OnStateChangedRequest {
14236 type Owned = Self;
14237
14238 #[inline(always)]
14239 fn inline_align(_context: fidl::encoding::Context) -> usize {
14240 8
14241 }
14242
14243 #[inline(always)]
14244 fn inline_size(_context: fidl::encoding::Context) -> usize {
14245 32
14246 }
14247 }
14248
14249 unsafe impl<D: fidl::encoding::ResourceDialect>
14250 fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D>
14251 for &UsageWatcher2OnStateChangedRequest
14252 {
14253 #[inline]
14254 unsafe fn encode(
14255 self,
14256 encoder: &mut fidl::encoding::Encoder<'_, D>,
14257 offset: usize,
14258 _depth: fidl::encoding::Depth,
14259 ) -> fidl::Result<()> {
14260 encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14261 fidl::encoding::Encode::<UsageWatcher2OnStateChangedRequest, D>::encode(
14263 (
14264 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14265 <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14266 ),
14267 encoder,
14268 offset,
14269 _depth,
14270 )
14271 }
14272 }
14273 unsafe impl<
14274 D: fidl::encoding::ResourceDialect,
14275 T0: fidl::encoding::Encode<Usage2, D>,
14276 T1: fidl::encoding::Encode<UsageState, D>,
14277 > fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D> for (T0, T1)
14278 {
14279 #[inline]
14280 unsafe fn encode(
14281 self,
14282 encoder: &mut fidl::encoding::Encoder<'_, D>,
14283 offset: usize,
14284 depth: fidl::encoding::Depth,
14285 ) -> fidl::Result<()> {
14286 encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14287 self.0.encode(encoder, offset + 0, depth)?;
14291 self.1.encode(encoder, offset + 16, depth)?;
14292 Ok(())
14293 }
14294 }
14295
14296 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14297 for UsageWatcher2OnStateChangedRequest
14298 {
14299 #[inline(always)]
14300 fn new_empty() -> Self {
14301 Self { usage: fidl::new_empty!(Usage2, D), state: fidl::new_empty!(UsageState, D) }
14302 }
14303
14304 #[inline]
14305 unsafe fn decode(
14306 &mut self,
14307 decoder: &mut fidl::encoding::Decoder<'_, D>,
14308 offset: usize,
14309 _depth: fidl::encoding::Depth,
14310 ) -> fidl::Result<()> {
14311 decoder.debug_check_bounds::<Self>(offset);
14312 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
14314 fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14315 Ok(())
14316 }
14317 }
14318
14319 impl fidl::encoding::ValueTypeMarker for UsageWatcherOnStateChangedRequest {
14320 type Borrowed<'a> = &'a Self;
14321 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14322 value
14323 }
14324 }
14325
14326 unsafe impl fidl::encoding::TypeMarker for UsageWatcherOnStateChangedRequest {
14327 type Owned = Self;
14328
14329 #[inline(always)]
14330 fn inline_align(_context: fidl::encoding::Context) -> usize {
14331 8
14332 }
14333
14334 #[inline(always)]
14335 fn inline_size(_context: fidl::encoding::Context) -> usize {
14336 32
14337 }
14338 }
14339
14340 unsafe impl<D: fidl::encoding::ResourceDialect>
14341 fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D>
14342 for &UsageWatcherOnStateChangedRequest
14343 {
14344 #[inline]
14345 unsafe fn encode(
14346 self,
14347 encoder: &mut fidl::encoding::Encoder<'_, D>,
14348 offset: usize,
14349 _depth: fidl::encoding::Depth,
14350 ) -> fidl::Result<()> {
14351 encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14352 fidl::encoding::Encode::<UsageWatcherOnStateChangedRequest, D>::encode(
14354 (
14355 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14356 <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14357 ),
14358 encoder,
14359 offset,
14360 _depth,
14361 )
14362 }
14363 }
14364 unsafe impl<
14365 D: fidl::encoding::ResourceDialect,
14366 T0: fidl::encoding::Encode<Usage, D>,
14367 T1: fidl::encoding::Encode<UsageState, D>,
14368 > fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D> for (T0, T1)
14369 {
14370 #[inline]
14371 unsafe fn encode(
14372 self,
14373 encoder: &mut fidl::encoding::Encoder<'_, D>,
14374 offset: usize,
14375 depth: fidl::encoding::Depth,
14376 ) -> fidl::Result<()> {
14377 encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14378 self.0.encode(encoder, offset + 0, depth)?;
14382 self.1.encode(encoder, offset + 16, depth)?;
14383 Ok(())
14384 }
14385 }
14386
14387 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14388 for UsageWatcherOnStateChangedRequest
14389 {
14390 #[inline(always)]
14391 fn new_empty() -> Self {
14392 Self { usage: fidl::new_empty!(Usage, D), state: fidl::new_empty!(UsageState, D) }
14393 }
14394
14395 #[inline]
14396 unsafe fn decode(
14397 &mut self,
14398 decoder: &mut fidl::encoding::Decoder<'_, D>,
14399 offset: usize,
14400 _depth: fidl::encoding::Depth,
14401 ) -> fidl::Result<()> {
14402 decoder.debug_check_bounds::<Self>(offset);
14403 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
14405 fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14406 Ok(())
14407 }
14408 }
14409
14410 impl fidl::encoding::ValueTypeMarker for VideoStreamType {
14411 type Borrowed<'a> = &'a Self;
14412 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14413 value
14414 }
14415 }
14416
14417 unsafe impl fidl::encoding::TypeMarker for VideoStreamType {
14418 type Owned = Self;
14419
14420 #[inline(always)]
14421 fn inline_align(_context: fidl::encoding::Context) -> usize {
14422 4
14423 }
14424
14425 #[inline(always)]
14426 fn inline_size(_context: fidl::encoding::Context) -> usize {
14427 36
14428 }
14429 }
14430
14431 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoStreamType, D>
14432 for &VideoStreamType
14433 {
14434 #[inline]
14435 unsafe fn encode(
14436 self,
14437 encoder: &mut fidl::encoding::Encoder<'_, D>,
14438 offset: usize,
14439 _depth: fidl::encoding::Depth,
14440 ) -> fidl::Result<()> {
14441 encoder.debug_check_bounds::<VideoStreamType>(offset);
14442 fidl::encoding::Encode::<VideoStreamType, D>::encode(
14444 (
14445 <fidl_fuchsia_images__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
14446 <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
14447 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
14448 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
14449 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_width),
14450 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_height),
14451 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14452 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14453 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.stride),
14454 ),
14455 encoder, offset, _depth
14456 )
14457 }
14458 }
14459 unsafe impl<
14460 D: fidl::encoding::ResourceDialect,
14461 T0: fidl::encoding::Encode<fidl_fuchsia_images__common::PixelFormat, D>,
14462 T1: fidl::encoding::Encode<ColorSpace, D>,
14463 T2: fidl::encoding::Encode<u32, D>,
14464 T3: fidl::encoding::Encode<u32, D>,
14465 T4: fidl::encoding::Encode<u32, D>,
14466 T5: fidl::encoding::Encode<u32, D>,
14467 T6: fidl::encoding::Encode<u32, D>,
14468 T7: fidl::encoding::Encode<u32, D>,
14469 T8: fidl::encoding::Encode<u32, D>,
14470 > fidl::encoding::Encode<VideoStreamType, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
14471 {
14472 #[inline]
14473 unsafe fn encode(
14474 self,
14475 encoder: &mut fidl::encoding::Encoder<'_, D>,
14476 offset: usize,
14477 depth: fidl::encoding::Depth,
14478 ) -> fidl::Result<()> {
14479 encoder.debug_check_bounds::<VideoStreamType>(offset);
14480 self.0.encode(encoder, offset + 0, depth)?;
14484 self.1.encode(encoder, offset + 4, depth)?;
14485 self.2.encode(encoder, offset + 8, depth)?;
14486 self.3.encode(encoder, offset + 12, depth)?;
14487 self.4.encode(encoder, offset + 16, depth)?;
14488 self.5.encode(encoder, offset + 20, depth)?;
14489 self.6.encode(encoder, offset + 24, depth)?;
14490 self.7.encode(encoder, offset + 28, depth)?;
14491 self.8.encode(encoder, offset + 32, depth)?;
14492 Ok(())
14493 }
14494 }
14495
14496 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoStreamType {
14497 #[inline(always)]
14498 fn new_empty() -> Self {
14499 Self {
14500 pixel_format: fidl::new_empty!(fidl_fuchsia_images__common::PixelFormat, D),
14501 color_space: fidl::new_empty!(ColorSpace, D),
14502 width: fidl::new_empty!(u32, D),
14503 height: fidl::new_empty!(u32, D),
14504 coded_width: fidl::new_empty!(u32, D),
14505 coded_height: fidl::new_empty!(u32, D),
14506 pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14507 pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14508 stride: fidl::new_empty!(u32, D),
14509 }
14510 }
14511
14512 #[inline]
14513 unsafe fn decode(
14514 &mut self,
14515 decoder: &mut fidl::encoding::Decoder<'_, D>,
14516 offset: usize,
14517 _depth: fidl::encoding::Depth,
14518 ) -> fidl::Result<()> {
14519 decoder.debug_check_bounds::<Self>(offset);
14520 fidl::decode!(
14522 fidl_fuchsia_images__common::PixelFormat,
14523 D,
14524 &mut self.pixel_format,
14525 decoder,
14526 offset + 0,
14527 _depth
14528 )?;
14529 fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 4, _depth)?;
14530 fidl::decode!(u32, D, &mut self.width, decoder, offset + 8, _depth)?;
14531 fidl::decode!(u32, D, &mut self.height, decoder, offset + 12, _depth)?;
14532 fidl::decode!(u32, D, &mut self.coded_width, decoder, offset + 16, _depth)?;
14533 fidl::decode!(u32, D, &mut self.coded_height, decoder, offset + 20, _depth)?;
14534 fidl::decode!(
14535 u32,
14536 D,
14537 &mut self.pixel_aspect_ratio_width,
14538 decoder,
14539 offset + 24,
14540 _depth
14541 )?;
14542 fidl::decode!(
14543 u32,
14544 D,
14545 &mut self.pixel_aspect_ratio_height,
14546 decoder,
14547 offset + 28,
14548 _depth
14549 )?;
14550 fidl::decode!(u32, D, &mut self.stride, decoder, offset + 32, _depth)?;
14551 Ok(())
14552 }
14553 }
14554
14555 impl fidl::encoding::ValueTypeMarker for VideoUncompressedFormat {
14556 type Borrowed<'a> = &'a Self;
14557 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14558 value
14559 }
14560 }
14561
14562 unsafe impl fidl::encoding::TypeMarker for VideoUncompressedFormat {
14563 type Owned = Self;
14564
14565 #[inline(always)]
14566 fn inline_align(_context: fidl::encoding::Context) -> usize {
14567 8
14568 }
14569
14570 #[inline(always)]
14571 fn inline_size(_context: fidl::encoding::Context) -> usize {
14572 128
14573 }
14574 }
14575
14576 unsafe impl<D: fidl::encoding::ResourceDialect>
14577 fidl::encoding::Encode<VideoUncompressedFormat, D> for &VideoUncompressedFormat
14578 {
14579 #[inline]
14580 unsafe fn encode(
14581 self,
14582 encoder: &mut fidl::encoding::Encoder<'_, D>,
14583 offset: usize,
14584 _depth: fidl::encoding::Depth,
14585 ) -> fidl::Result<()> {
14586 encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14587 fidl::encoding::Encode::<VideoUncompressedFormat, D>::encode(
14589 (
14590 <fidl_fuchsia_sysmem__common::ImageFormat2 as fidl::encoding::ValueTypeMarker>::borrow(&self.image_format),
14591 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.fourcc),
14592 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_width_pixels),
14593 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_height_pixels),
14594 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_width_pixels),
14595 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_height_pixels),
14596 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.planar),
14597 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.swizzled),
14598 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_line_stride_bytes),
14599 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_line_stride_bytes),
14600 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_start_offset),
14601 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_start_offset),
14602 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.tertiary_start_offset),
14603 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_pixel_stride),
14604 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_pixel_stride),
14605 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_width_pixels),
14606 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_height_pixels),
14607 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_pixel_aspect_ratio),
14608 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14609 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14610 ),
14611 encoder, offset, _depth
14612 )
14613 }
14614 }
14615 unsafe impl<
14616 D: fidl::encoding::ResourceDialect,
14617 T0: fidl::encoding::Encode<fidl_fuchsia_sysmem__common::ImageFormat2, D>,
14618 T1: fidl::encoding::Encode<u32, D>,
14619 T2: fidl::encoding::Encode<u32, D>,
14620 T3: fidl::encoding::Encode<u32, D>,
14621 T4: fidl::encoding::Encode<u32, D>,
14622 T5: fidl::encoding::Encode<u32, D>,
14623 T6: fidl::encoding::Encode<bool, D>,
14624 T7: fidl::encoding::Encode<bool, D>,
14625 T8: fidl::encoding::Encode<u32, D>,
14626 T9: fidl::encoding::Encode<u32, D>,
14627 T10: fidl::encoding::Encode<u32, D>,
14628 T11: fidl::encoding::Encode<u32, D>,
14629 T12: fidl::encoding::Encode<u32, D>,
14630 T13: fidl::encoding::Encode<u32, D>,
14631 T14: fidl::encoding::Encode<u32, D>,
14632 T15: fidl::encoding::Encode<u32, D>,
14633 T16: fidl::encoding::Encode<u32, D>,
14634 T17: fidl::encoding::Encode<bool, D>,
14635 T18: fidl::encoding::Encode<u32, D>,
14636 T19: fidl::encoding::Encode<u32, D>,
14637 > fidl::encoding::Encode<VideoUncompressedFormat, D>
14638 for (
14639 T0,
14640 T1,
14641 T2,
14642 T3,
14643 T4,
14644 T5,
14645 T6,
14646 T7,
14647 T8,
14648 T9,
14649 T10,
14650 T11,
14651 T12,
14652 T13,
14653 T14,
14654 T15,
14655 T16,
14656 T17,
14657 T18,
14658 T19,
14659 )
14660 {
14661 #[inline]
14662 unsafe fn encode(
14663 self,
14664 encoder: &mut fidl::encoding::Encoder<'_, D>,
14665 offset: usize,
14666 depth: fidl::encoding::Depth,
14667 ) -> fidl::Result<()> {
14668 encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14669 unsafe {
14672 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
14673 (ptr as *mut u64).write_unaligned(0);
14674 }
14675 unsafe {
14676 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
14677 (ptr as *mut u64).write_unaligned(0);
14678 }
14679 self.0.encode(encoder, offset + 0, depth)?;
14681 self.1.encode(encoder, offset + 56, depth)?;
14682 self.2.encode(encoder, offset + 60, depth)?;
14683 self.3.encode(encoder, offset + 64, depth)?;
14684 self.4.encode(encoder, offset + 68, depth)?;
14685 self.5.encode(encoder, offset + 72, depth)?;
14686 self.6.encode(encoder, offset + 76, depth)?;
14687 self.7.encode(encoder, offset + 77, depth)?;
14688 self.8.encode(encoder, offset + 80, depth)?;
14689 self.9.encode(encoder, offset + 84, depth)?;
14690 self.10.encode(encoder, offset + 88, depth)?;
14691 self.11.encode(encoder, offset + 92, depth)?;
14692 self.12.encode(encoder, offset + 96, depth)?;
14693 self.13.encode(encoder, offset + 100, depth)?;
14694 self.14.encode(encoder, offset + 104, depth)?;
14695 self.15.encode(encoder, offset + 108, depth)?;
14696 self.16.encode(encoder, offset + 112, depth)?;
14697 self.17.encode(encoder, offset + 116, depth)?;
14698 self.18.encode(encoder, offset + 120, depth)?;
14699 self.19.encode(encoder, offset + 124, depth)?;
14700 Ok(())
14701 }
14702 }
14703
14704 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14705 for VideoUncompressedFormat
14706 {
14707 #[inline(always)]
14708 fn new_empty() -> Self {
14709 Self {
14710 image_format: fidl::new_empty!(fidl_fuchsia_sysmem__common::ImageFormat2, D),
14711 fourcc: fidl::new_empty!(u32, D),
14712 primary_width_pixels: fidl::new_empty!(u32, D),
14713 primary_height_pixels: fidl::new_empty!(u32, D),
14714 secondary_width_pixels: fidl::new_empty!(u32, D),
14715 secondary_height_pixels: fidl::new_empty!(u32, D),
14716 planar: fidl::new_empty!(bool, D),
14717 swizzled: fidl::new_empty!(bool, D),
14718 primary_line_stride_bytes: fidl::new_empty!(u32, D),
14719 secondary_line_stride_bytes: fidl::new_empty!(u32, D),
14720 primary_start_offset: fidl::new_empty!(u32, D),
14721 secondary_start_offset: fidl::new_empty!(u32, D),
14722 tertiary_start_offset: fidl::new_empty!(u32, D),
14723 primary_pixel_stride: fidl::new_empty!(u32, D),
14724 secondary_pixel_stride: fidl::new_empty!(u32, D),
14725 primary_display_width_pixels: fidl::new_empty!(u32, D),
14726 primary_display_height_pixels: fidl::new_empty!(u32, D),
14727 has_pixel_aspect_ratio: fidl::new_empty!(bool, D),
14728 pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14729 pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14730 }
14731 }
14732
14733 #[inline]
14734 unsafe fn decode(
14735 &mut self,
14736 decoder: &mut fidl::encoding::Decoder<'_, D>,
14737 offset: usize,
14738 _depth: fidl::encoding::Depth,
14739 ) -> fidl::Result<()> {
14740 decoder.debug_check_bounds::<Self>(offset);
14741 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
14743 let padval = unsafe { (ptr as *const u64).read_unaligned() };
14744 let mask = 0xffff000000000000u64;
14745 let maskedval = padval & mask;
14746 if maskedval != 0 {
14747 return Err(fidl::Error::NonZeroPadding {
14748 padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
14749 });
14750 }
14751 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
14752 let padval = unsafe { (ptr as *const u64).read_unaligned() };
14753 let mask = 0xffffff0000000000u64;
14754 let maskedval = padval & mask;
14755 if maskedval != 0 {
14756 return Err(fidl::Error::NonZeroPadding {
14757 padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
14758 });
14759 }
14760 fidl::decode!(
14761 fidl_fuchsia_sysmem__common::ImageFormat2,
14762 D,
14763 &mut self.image_format,
14764 decoder,
14765 offset + 0,
14766 _depth
14767 )?;
14768 fidl::decode!(u32, D, &mut self.fourcc, decoder, offset + 56, _depth)?;
14769 fidl::decode!(u32, D, &mut self.primary_width_pixels, decoder, offset + 60, _depth)?;
14770 fidl::decode!(u32, D, &mut self.primary_height_pixels, decoder, offset + 64, _depth)?;
14771 fidl::decode!(u32, D, &mut self.secondary_width_pixels, decoder, offset + 68, _depth)?;
14772 fidl::decode!(u32, D, &mut self.secondary_height_pixels, decoder, offset + 72, _depth)?;
14773 fidl::decode!(bool, D, &mut self.planar, decoder, offset + 76, _depth)?;
14774 fidl::decode!(bool, D, &mut self.swizzled, decoder, offset + 77, _depth)?;
14775 fidl::decode!(
14776 u32,
14777 D,
14778 &mut self.primary_line_stride_bytes,
14779 decoder,
14780 offset + 80,
14781 _depth
14782 )?;
14783 fidl::decode!(
14784 u32,
14785 D,
14786 &mut self.secondary_line_stride_bytes,
14787 decoder,
14788 offset + 84,
14789 _depth
14790 )?;
14791 fidl::decode!(u32, D, &mut self.primary_start_offset, decoder, offset + 88, _depth)?;
14792 fidl::decode!(u32, D, &mut self.secondary_start_offset, decoder, offset + 92, _depth)?;
14793 fidl::decode!(u32, D, &mut self.tertiary_start_offset, decoder, offset + 96, _depth)?;
14794 fidl::decode!(u32, D, &mut self.primary_pixel_stride, decoder, offset + 100, _depth)?;
14795 fidl::decode!(u32, D, &mut self.secondary_pixel_stride, decoder, offset + 104, _depth)?;
14796 fidl::decode!(
14797 u32,
14798 D,
14799 &mut self.primary_display_width_pixels,
14800 decoder,
14801 offset + 108,
14802 _depth
14803 )?;
14804 fidl::decode!(
14805 u32,
14806 D,
14807 &mut self.primary_display_height_pixels,
14808 decoder,
14809 offset + 112,
14810 _depth
14811 )?;
14812 fidl::decode!(
14813 bool,
14814 D,
14815 &mut self.has_pixel_aspect_ratio,
14816 decoder,
14817 offset + 116,
14818 _depth
14819 )?;
14820 fidl::decode!(
14821 u32,
14822 D,
14823 &mut self.pixel_aspect_ratio_width,
14824 decoder,
14825 offset + 120,
14826 _depth
14827 )?;
14828 fidl::decode!(
14829 u32,
14830 D,
14831 &mut self.pixel_aspect_ratio_height,
14832 decoder,
14833 offset + 124,
14834 _depth
14835 )?;
14836 Ok(())
14837 }
14838 }
14839
14840 impl fidl::encoding::ValueTypeMarker for Void {
14841 type Borrowed<'a> = &'a Self;
14842 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14843 value
14844 }
14845 }
14846
14847 unsafe impl fidl::encoding::TypeMarker for Void {
14848 type Owned = Self;
14849
14850 #[inline(always)]
14851 fn inline_align(_context: fidl::encoding::Context) -> usize {
14852 1
14853 }
14854
14855 #[inline(always)]
14856 fn inline_size(_context: fidl::encoding::Context) -> usize {
14857 1
14858 }
14859 }
14860
14861 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
14862 #[inline]
14863 unsafe fn encode(
14864 self,
14865 encoder: &mut fidl::encoding::Encoder<'_, D>,
14866 offset: usize,
14867 _depth: fidl::encoding::Depth,
14868 ) -> fidl::Result<()> {
14869 encoder.debug_check_bounds::<Void>(offset);
14870 encoder.write_num(0u8, offset);
14871 Ok(())
14872 }
14873 }
14874
14875 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
14876 #[inline(always)]
14877 fn new_empty() -> Self {
14878 Self
14879 }
14880
14881 #[inline]
14882 unsafe fn decode(
14883 &mut self,
14884 decoder: &mut fidl::encoding::Decoder<'_, D>,
14885 offset: usize,
14886 _depth: fidl::encoding::Depth,
14887 ) -> fidl::Result<()> {
14888 decoder.debug_check_bounds::<Self>(offset);
14889 match decoder.read_num::<u8>(offset) {
14890 0 => Ok(()),
14891 _ => Err(fidl::Error::Invalid),
14892 }
14893 }
14894 }
14895
14896 impl AudioCompressedFormatCvsd {
14897 #[inline(always)]
14898 fn max_ordinal_present(&self) -> u64 {
14899 0
14900 }
14901 }
14902
14903 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatCvsd {
14904 type Borrowed<'a> = &'a Self;
14905 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14906 value
14907 }
14908 }
14909
14910 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatCvsd {
14911 type Owned = Self;
14912
14913 #[inline(always)]
14914 fn inline_align(_context: fidl::encoding::Context) -> usize {
14915 8
14916 }
14917
14918 #[inline(always)]
14919 fn inline_size(_context: fidl::encoding::Context) -> usize {
14920 16
14921 }
14922 }
14923
14924 unsafe impl<D: fidl::encoding::ResourceDialect>
14925 fidl::encoding::Encode<AudioCompressedFormatCvsd, D> for &AudioCompressedFormatCvsd
14926 {
14927 unsafe fn encode(
14928 self,
14929 encoder: &mut fidl::encoding::Encoder<'_, D>,
14930 offset: usize,
14931 mut depth: fidl::encoding::Depth,
14932 ) -> fidl::Result<()> {
14933 encoder.debug_check_bounds::<AudioCompressedFormatCvsd>(offset);
14934 let max_ordinal: u64 = self.max_ordinal_present();
14936 encoder.write_num(max_ordinal, offset);
14937 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14938 if max_ordinal == 0 {
14940 return Ok(());
14941 }
14942 depth.increment()?;
14943 let envelope_size = 8;
14944 let bytes_len = max_ordinal as usize * envelope_size;
14945 #[allow(unused_variables)]
14946 let offset = encoder.out_of_line_offset(bytes_len);
14947 let mut _prev_end_offset: usize = 0;
14948
14949 Ok(())
14950 }
14951 }
14952
14953 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14954 for AudioCompressedFormatCvsd
14955 {
14956 #[inline(always)]
14957 fn new_empty() -> Self {
14958 Self::default()
14959 }
14960
14961 unsafe fn decode(
14962 &mut self,
14963 decoder: &mut fidl::encoding::Decoder<'_, D>,
14964 offset: usize,
14965 mut depth: fidl::encoding::Depth,
14966 ) -> fidl::Result<()> {
14967 decoder.debug_check_bounds::<Self>(offset);
14968 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14969 None => return Err(fidl::Error::NotNullable),
14970 Some(len) => len,
14971 };
14972 if len == 0 {
14974 return Ok(());
14975 };
14976 depth.increment()?;
14977 let envelope_size = 8;
14978 let bytes_len = len * envelope_size;
14979 let offset = decoder.out_of_line_offset(bytes_len)?;
14980 let mut _next_ordinal_to_read = 0;
14982 let mut next_offset = offset;
14983 let end_offset = offset + bytes_len;
14984
14985 while next_offset < end_offset {
14987 _next_ordinal_to_read += 1;
14988 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14989 next_offset += envelope_size;
14990 }
14991
14992 Ok(())
14993 }
14994 }
14995
14996 impl AudioCompressedFormatLc3 {
14997 #[inline(always)]
14998 fn max_ordinal_present(&self) -> u64 {
14999 0
15000 }
15001 }
15002
15003 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatLc3 {
15004 type Borrowed<'a> = &'a Self;
15005 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15006 value
15007 }
15008 }
15009
15010 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatLc3 {
15011 type Owned = Self;
15012
15013 #[inline(always)]
15014 fn inline_align(_context: fidl::encoding::Context) -> usize {
15015 8
15016 }
15017
15018 #[inline(always)]
15019 fn inline_size(_context: fidl::encoding::Context) -> usize {
15020 16
15021 }
15022 }
15023
15024 unsafe impl<D: fidl::encoding::ResourceDialect>
15025 fidl::encoding::Encode<AudioCompressedFormatLc3, D> for &AudioCompressedFormatLc3
15026 {
15027 unsafe fn encode(
15028 self,
15029 encoder: &mut fidl::encoding::Encoder<'_, D>,
15030 offset: usize,
15031 mut depth: fidl::encoding::Depth,
15032 ) -> fidl::Result<()> {
15033 encoder.debug_check_bounds::<AudioCompressedFormatLc3>(offset);
15034 let max_ordinal: u64 = self.max_ordinal_present();
15036 encoder.write_num(max_ordinal, offset);
15037 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15038 if max_ordinal == 0 {
15040 return Ok(());
15041 }
15042 depth.increment()?;
15043 let envelope_size = 8;
15044 let bytes_len = max_ordinal as usize * envelope_size;
15045 #[allow(unused_variables)]
15046 let offset = encoder.out_of_line_offset(bytes_len);
15047 let mut _prev_end_offset: usize = 0;
15048
15049 Ok(())
15050 }
15051 }
15052
15053 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
15054 for AudioCompressedFormatLc3
15055 {
15056 #[inline(always)]
15057 fn new_empty() -> Self {
15058 Self::default()
15059 }
15060
15061 unsafe fn decode(
15062 &mut self,
15063 decoder: &mut fidl::encoding::Decoder<'_, D>,
15064 offset: usize,
15065 mut depth: fidl::encoding::Depth,
15066 ) -> fidl::Result<()> {
15067 decoder.debug_check_bounds::<Self>(offset);
15068 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15069 None => return Err(fidl::Error::NotNullable),
15070 Some(len) => len,
15071 };
15072 if len == 0 {
15074 return Ok(());
15075 };
15076 depth.increment()?;
15077 let envelope_size = 8;
15078 let bytes_len = len * envelope_size;
15079 let offset = decoder.out_of_line_offset(bytes_len)?;
15080 let mut _next_ordinal_to_read = 0;
15082 let mut next_offset = offset;
15083 let end_offset = offset + bytes_len;
15084
15085 while next_offset < end_offset {
15087 _next_ordinal_to_read += 1;
15088 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15089 next_offset += envelope_size;
15090 }
15091
15092 Ok(())
15093 }
15094 }
15095
15096 impl AudioConsumerStatus {
15097 #[inline(always)]
15098 fn max_ordinal_present(&self) -> u64 {
15099 if let Some(_) = self.max_lead_time {
15100 return 4;
15101 }
15102 if let Some(_) = self.min_lead_time {
15103 return 3;
15104 }
15105 if let Some(_) = self.presentation_timeline {
15106 return 2;
15107 }
15108 if let Some(_) = self.error {
15109 return 1;
15110 }
15111 0
15112 }
15113 }
15114
15115 impl fidl::encoding::ValueTypeMarker for AudioConsumerStatus {
15116 type Borrowed<'a> = &'a Self;
15117 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15118 value
15119 }
15120 }
15121
15122 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStatus {
15123 type Owned = Self;
15124
15125 #[inline(always)]
15126 fn inline_align(_context: fidl::encoding::Context) -> usize {
15127 8
15128 }
15129
15130 #[inline(always)]
15131 fn inline_size(_context: fidl::encoding::Context) -> usize {
15132 16
15133 }
15134 }
15135
15136 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerStatus, D>
15137 for &AudioConsumerStatus
15138 {
15139 unsafe fn encode(
15140 self,
15141 encoder: &mut fidl::encoding::Encoder<'_, D>,
15142 offset: usize,
15143 mut depth: fidl::encoding::Depth,
15144 ) -> fidl::Result<()> {
15145 encoder.debug_check_bounds::<AudioConsumerStatus>(offset);
15146 let max_ordinal: u64 = self.max_ordinal_present();
15148 encoder.write_num(max_ordinal, offset);
15149 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15150 if max_ordinal == 0 {
15152 return Ok(());
15153 }
15154 depth.increment()?;
15155 let envelope_size = 8;
15156 let bytes_len = max_ordinal as usize * envelope_size;
15157 #[allow(unused_variables)]
15158 let offset = encoder.out_of_line_offset(bytes_len);
15159 let mut _prev_end_offset: usize = 0;
15160 if 1 > max_ordinal {
15161 return Ok(());
15162 }
15163
15164 let cur_offset: usize = (1 - 1) * envelope_size;
15167
15168 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15170
15171 fidl::encoding::encode_in_envelope_optional::<AudioConsumerError, D>(
15176 self.error
15177 .as_ref()
15178 .map(<AudioConsumerError as fidl::encoding::ValueTypeMarker>::borrow),
15179 encoder,
15180 offset + cur_offset,
15181 depth,
15182 )?;
15183
15184 _prev_end_offset = cur_offset + envelope_size;
15185 if 2 > max_ordinal {
15186 return Ok(());
15187 }
15188
15189 let cur_offset: usize = (2 - 1) * envelope_size;
15192
15193 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15195
15196 fidl::encoding::encode_in_envelope_optional::<TimelineFunction, D>(
15201 self.presentation_timeline
15202 .as_ref()
15203 .map(<TimelineFunction as fidl::encoding::ValueTypeMarker>::borrow),
15204 encoder,
15205 offset + cur_offset,
15206 depth,
15207 )?;
15208
15209 _prev_end_offset = cur_offset + envelope_size;
15210 if 3 > max_ordinal {
15211 return Ok(());
15212 }
15213
15214 let cur_offset: usize = (3 - 1) * envelope_size;
15217
15218 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15220
15221 fidl::encoding::encode_in_envelope_optional::<u64, D>(
15226 self.min_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15227 encoder,
15228 offset + cur_offset,
15229 depth,
15230 )?;
15231
15232 _prev_end_offset = cur_offset + envelope_size;
15233 if 4 > max_ordinal {
15234 return Ok(());
15235 }
15236
15237 let cur_offset: usize = (4 - 1) * envelope_size;
15240
15241 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15243
15244 fidl::encoding::encode_in_envelope_optional::<u64, D>(
15249 self.max_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15250 encoder,
15251 offset + cur_offset,
15252 depth,
15253 )?;
15254
15255 _prev_end_offset = cur_offset + envelope_size;
15256
15257 Ok(())
15258 }
15259 }
15260
15261 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerStatus {
15262 #[inline(always)]
15263 fn new_empty() -> Self {
15264 Self::default()
15265 }
15266
15267 unsafe fn decode(
15268 &mut self,
15269 decoder: &mut fidl::encoding::Decoder<'_, D>,
15270 offset: usize,
15271 mut depth: fidl::encoding::Depth,
15272 ) -> fidl::Result<()> {
15273 decoder.debug_check_bounds::<Self>(offset);
15274 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15275 None => return Err(fidl::Error::NotNullable),
15276 Some(len) => len,
15277 };
15278 if len == 0 {
15280 return Ok(());
15281 };
15282 depth.increment()?;
15283 let envelope_size = 8;
15284 let bytes_len = len * envelope_size;
15285 let offset = decoder.out_of_line_offset(bytes_len)?;
15286 let mut _next_ordinal_to_read = 0;
15288 let mut next_offset = offset;
15289 let end_offset = offset + bytes_len;
15290 _next_ordinal_to_read += 1;
15291 if next_offset >= end_offset {
15292 return Ok(());
15293 }
15294
15295 while _next_ordinal_to_read < 1 {
15297 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15298 _next_ordinal_to_read += 1;
15299 next_offset += envelope_size;
15300 }
15301
15302 let next_out_of_line = decoder.next_out_of_line();
15303 let handles_before = decoder.remaining_handles();
15304 if let Some((inlined, num_bytes, num_handles)) =
15305 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15306 {
15307 let member_inline_size =
15308 <AudioConsumerError as fidl::encoding::TypeMarker>::inline_size(
15309 decoder.context,
15310 );
15311 if inlined != (member_inline_size <= 4) {
15312 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15313 }
15314 let inner_offset;
15315 let mut inner_depth = depth.clone();
15316 if inlined {
15317 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15318 inner_offset = next_offset;
15319 } else {
15320 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15321 inner_depth.increment()?;
15322 }
15323 let val_ref =
15324 self.error.get_or_insert_with(|| fidl::new_empty!(AudioConsumerError, D));
15325 fidl::decode!(AudioConsumerError, D, val_ref, decoder, inner_offset, inner_depth)?;
15326 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15327 {
15328 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15329 }
15330 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15331 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15332 }
15333 }
15334
15335 next_offset += envelope_size;
15336 _next_ordinal_to_read += 1;
15337 if next_offset >= end_offset {
15338 return Ok(());
15339 }
15340
15341 while _next_ordinal_to_read < 2 {
15343 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15344 _next_ordinal_to_read += 1;
15345 next_offset += envelope_size;
15346 }
15347
15348 let next_out_of_line = decoder.next_out_of_line();
15349 let handles_before = decoder.remaining_handles();
15350 if let Some((inlined, num_bytes, num_handles)) =
15351 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15352 {
15353 let member_inline_size =
15354 <TimelineFunction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15355 if inlined != (member_inline_size <= 4) {
15356 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15357 }
15358 let inner_offset;
15359 let mut inner_depth = depth.clone();
15360 if inlined {
15361 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15362 inner_offset = next_offset;
15363 } else {
15364 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15365 inner_depth.increment()?;
15366 }
15367 let val_ref = self
15368 .presentation_timeline
15369 .get_or_insert_with(|| fidl::new_empty!(TimelineFunction, D));
15370 fidl::decode!(TimelineFunction, D, val_ref, decoder, inner_offset, inner_depth)?;
15371 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15372 {
15373 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15374 }
15375 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15376 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15377 }
15378 }
15379
15380 next_offset += envelope_size;
15381 _next_ordinal_to_read += 1;
15382 if next_offset >= end_offset {
15383 return Ok(());
15384 }
15385
15386 while _next_ordinal_to_read < 3 {
15388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15389 _next_ordinal_to_read += 1;
15390 next_offset += envelope_size;
15391 }
15392
15393 let next_out_of_line = decoder.next_out_of_line();
15394 let handles_before = decoder.remaining_handles();
15395 if let Some((inlined, num_bytes, num_handles)) =
15396 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15397 {
15398 let member_inline_size =
15399 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15400 if inlined != (member_inline_size <= 4) {
15401 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15402 }
15403 let inner_offset;
15404 let mut inner_depth = depth.clone();
15405 if inlined {
15406 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15407 inner_offset = next_offset;
15408 } else {
15409 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15410 inner_depth.increment()?;
15411 }
15412 let val_ref = self.min_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15413 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15414 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15415 {
15416 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15417 }
15418 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15419 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15420 }
15421 }
15422
15423 next_offset += envelope_size;
15424 _next_ordinal_to_read += 1;
15425 if next_offset >= end_offset {
15426 return Ok(());
15427 }
15428
15429 while _next_ordinal_to_read < 4 {
15431 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15432 _next_ordinal_to_read += 1;
15433 next_offset += envelope_size;
15434 }
15435
15436 let next_out_of_line = decoder.next_out_of_line();
15437 let handles_before = decoder.remaining_handles();
15438 if let Some((inlined, num_bytes, num_handles)) =
15439 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15440 {
15441 let member_inline_size =
15442 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15443 if inlined != (member_inline_size <= 4) {
15444 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15445 }
15446 let inner_offset;
15447 let mut inner_depth = depth.clone();
15448 if inlined {
15449 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15450 inner_offset = next_offset;
15451 } else {
15452 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15453 inner_depth.increment()?;
15454 }
15455 let val_ref = self.max_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15456 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15457 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15458 {
15459 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15460 }
15461 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15462 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15463 }
15464 }
15465
15466 next_offset += envelope_size;
15467
15468 while next_offset < end_offset {
15470 _next_ordinal_to_read += 1;
15471 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15472 next_offset += envelope_size;
15473 }
15474
15475 Ok(())
15476 }
15477 }
15478
15479 impl CvsdEncoderSettings {
15480 #[inline(always)]
15481 fn max_ordinal_present(&self) -> u64 {
15482 0
15483 }
15484 }
15485
15486 impl fidl::encoding::ValueTypeMarker for CvsdEncoderSettings {
15487 type Borrowed<'a> = &'a Self;
15488 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15489 value
15490 }
15491 }
15492
15493 unsafe impl fidl::encoding::TypeMarker for CvsdEncoderSettings {
15494 type Owned = Self;
15495
15496 #[inline(always)]
15497 fn inline_align(_context: fidl::encoding::Context) -> usize {
15498 8
15499 }
15500
15501 #[inline(always)]
15502 fn inline_size(_context: fidl::encoding::Context) -> usize {
15503 16
15504 }
15505 }
15506
15507 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CvsdEncoderSettings, D>
15508 for &CvsdEncoderSettings
15509 {
15510 unsafe fn encode(
15511 self,
15512 encoder: &mut fidl::encoding::Encoder<'_, D>,
15513 offset: usize,
15514 mut depth: fidl::encoding::Depth,
15515 ) -> fidl::Result<()> {
15516 encoder.debug_check_bounds::<CvsdEncoderSettings>(offset);
15517 let max_ordinal: u64 = self.max_ordinal_present();
15519 encoder.write_num(max_ordinal, offset);
15520 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15521 if max_ordinal == 0 {
15523 return Ok(());
15524 }
15525 depth.increment()?;
15526 let envelope_size = 8;
15527 let bytes_len = max_ordinal as usize * envelope_size;
15528 #[allow(unused_variables)]
15529 let offset = encoder.out_of_line_offset(bytes_len);
15530 let mut _prev_end_offset: usize = 0;
15531
15532 Ok(())
15533 }
15534 }
15535
15536 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CvsdEncoderSettings {
15537 #[inline(always)]
15538 fn new_empty() -> Self {
15539 Self::default()
15540 }
15541
15542 unsafe fn decode(
15543 &mut self,
15544 decoder: &mut fidl::encoding::Decoder<'_, D>,
15545 offset: usize,
15546 mut depth: fidl::encoding::Depth,
15547 ) -> fidl::Result<()> {
15548 decoder.debug_check_bounds::<Self>(offset);
15549 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15550 None => return Err(fidl::Error::NotNullable),
15551 Some(len) => len,
15552 };
15553 if len == 0 {
15555 return Ok(());
15556 };
15557 depth.increment()?;
15558 let envelope_size = 8;
15559 let bytes_len = len * envelope_size;
15560 let offset = decoder.out_of_line_offset(bytes_len)?;
15561 let mut _next_ordinal_to_read = 0;
15563 let mut next_offset = offset;
15564 let end_offset = offset + bytes_len;
15565
15566 while next_offset < end_offset {
15568 _next_ordinal_to_read += 1;
15569 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15570 next_offset += envelope_size;
15571 }
15572
15573 Ok(())
15574 }
15575 }
15576
15577 impl DecryptedFormat {
15578 #[inline(always)]
15579 fn max_ordinal_present(&self) -> u64 {
15580 if let Some(_) = self.ignore_this_field {
15581 return 1;
15582 }
15583 0
15584 }
15585 }
15586
15587 impl fidl::encoding::ValueTypeMarker for DecryptedFormat {
15588 type Borrowed<'a> = &'a Self;
15589 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15590 value
15591 }
15592 }
15593
15594 unsafe impl fidl::encoding::TypeMarker for DecryptedFormat {
15595 type Owned = Self;
15596
15597 #[inline(always)]
15598 fn inline_align(_context: fidl::encoding::Context) -> usize {
15599 8
15600 }
15601
15602 #[inline(always)]
15603 fn inline_size(_context: fidl::encoding::Context) -> usize {
15604 16
15605 }
15606 }
15607
15608 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DecryptedFormat, D>
15609 for &DecryptedFormat
15610 {
15611 unsafe fn encode(
15612 self,
15613 encoder: &mut fidl::encoding::Encoder<'_, D>,
15614 offset: usize,
15615 mut depth: fidl::encoding::Depth,
15616 ) -> fidl::Result<()> {
15617 encoder.debug_check_bounds::<DecryptedFormat>(offset);
15618 let max_ordinal: u64 = self.max_ordinal_present();
15620 encoder.write_num(max_ordinal, offset);
15621 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15622 if max_ordinal == 0 {
15624 return Ok(());
15625 }
15626 depth.increment()?;
15627 let envelope_size = 8;
15628 let bytes_len = max_ordinal as usize * envelope_size;
15629 #[allow(unused_variables)]
15630 let offset = encoder.out_of_line_offset(bytes_len);
15631 let mut _prev_end_offset: usize = 0;
15632 if 1 > max_ordinal {
15633 return Ok(());
15634 }
15635
15636 let cur_offset: usize = (1 - 1) * envelope_size;
15639
15640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15642
15643 fidl::encoding::encode_in_envelope_optional::<bool, D>(
15648 self.ignore_this_field
15649 .as_ref()
15650 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
15651 encoder,
15652 offset + cur_offset,
15653 depth,
15654 )?;
15655
15656 _prev_end_offset = cur_offset + envelope_size;
15657
15658 Ok(())
15659 }
15660 }
15661
15662 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DecryptedFormat {
15663 #[inline(always)]
15664 fn new_empty() -> Self {
15665 Self::default()
15666 }
15667
15668 unsafe fn decode(
15669 &mut self,
15670 decoder: &mut fidl::encoding::Decoder<'_, D>,
15671 offset: usize,
15672 mut depth: fidl::encoding::Depth,
15673 ) -> fidl::Result<()> {
15674 decoder.debug_check_bounds::<Self>(offset);
15675 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15676 None => return Err(fidl::Error::NotNullable),
15677 Some(len) => len,
15678 };
15679 if len == 0 {
15681 return Ok(());
15682 };
15683 depth.increment()?;
15684 let envelope_size = 8;
15685 let bytes_len = len * envelope_size;
15686 let offset = decoder.out_of_line_offset(bytes_len)?;
15687 let mut _next_ordinal_to_read = 0;
15689 let mut next_offset = offset;
15690 let end_offset = offset + bytes_len;
15691 _next_ordinal_to_read += 1;
15692 if next_offset >= end_offset {
15693 return Ok(());
15694 }
15695
15696 while _next_ordinal_to_read < 1 {
15698 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15699 _next_ordinal_to_read += 1;
15700 next_offset += envelope_size;
15701 }
15702
15703 let next_out_of_line = decoder.next_out_of_line();
15704 let handles_before = decoder.remaining_handles();
15705 if let Some((inlined, num_bytes, num_handles)) =
15706 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15707 {
15708 let member_inline_size =
15709 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15710 if inlined != (member_inline_size <= 4) {
15711 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15712 }
15713 let inner_offset;
15714 let mut inner_depth = depth.clone();
15715 if inlined {
15716 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15717 inner_offset = next_offset;
15718 } else {
15719 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15720 inner_depth.increment()?;
15721 }
15722 let val_ref =
15723 self.ignore_this_field.get_or_insert_with(|| fidl::new_empty!(bool, D));
15724 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
15725 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15726 {
15727 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15728 }
15729 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15730 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15731 }
15732 }
15733
15734 next_offset += envelope_size;
15735
15736 while next_offset < end_offset {
15738 _next_ordinal_to_read += 1;
15739 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15740 next_offset += envelope_size;
15741 }
15742
15743 Ok(())
15744 }
15745 }
15746
15747 impl EncryptedFormat {
15748 #[inline(always)]
15749 fn max_ordinal_present(&self) -> u64 {
15750 if let Some(_) = self.key_id {
15751 return 8;
15752 }
15753 if let Some(_) = self.scheme {
15754 return 6;
15755 }
15756 if let Some(_) = self.pattern {
15757 return 5;
15758 }
15759 if let Some(_) = self.subsamples {
15760 return 4;
15761 }
15762 if let Some(_) = self.init_vector {
15763 return 3;
15764 }
15765 0
15766 }
15767 }
15768
15769 impl fidl::encoding::ValueTypeMarker for EncryptedFormat {
15770 type Borrowed<'a> = &'a Self;
15771 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15772 value
15773 }
15774 }
15775
15776 unsafe impl fidl::encoding::TypeMarker for EncryptedFormat {
15777 type Owned = Self;
15778
15779 #[inline(always)]
15780 fn inline_align(_context: fidl::encoding::Context) -> usize {
15781 8
15782 }
15783
15784 #[inline(always)]
15785 fn inline_size(_context: fidl::encoding::Context) -> usize {
15786 16
15787 }
15788 }
15789
15790 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptedFormat, D>
15791 for &EncryptedFormat
15792 {
15793 unsafe fn encode(
15794 self,
15795 encoder: &mut fidl::encoding::Encoder<'_, D>,
15796 offset: usize,
15797 mut depth: fidl::encoding::Depth,
15798 ) -> fidl::Result<()> {
15799 encoder.debug_check_bounds::<EncryptedFormat>(offset);
15800 let max_ordinal: u64 = self.max_ordinal_present();
15802 encoder.write_num(max_ordinal, offset);
15803 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15804 if max_ordinal == 0 {
15806 return Ok(());
15807 }
15808 depth.increment()?;
15809 let envelope_size = 8;
15810 let bytes_len = max_ordinal as usize * envelope_size;
15811 #[allow(unused_variables)]
15812 let offset = encoder.out_of_line_offset(bytes_len);
15813 let mut _prev_end_offset: usize = 0;
15814 if 3 > max_ordinal {
15815 return Ok(());
15816 }
15817
15818 let cur_offset: usize = (3 - 1) * envelope_size;
15821
15822 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15824
15825 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15830 self.init_vector.as_ref().map(
15831 <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15832 ),
15833 encoder,
15834 offset + cur_offset,
15835 depth,
15836 )?;
15837
15838 _prev_end_offset = cur_offset + envelope_size;
15839 if 4 > max_ordinal {
15840 return Ok(());
15841 }
15842
15843 let cur_offset: usize = (4 - 1) * envelope_size;
15846
15847 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15849
15850 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<SubsampleEntry>, D>(
15855 self.subsamples.as_ref().map(<fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::ValueTypeMarker>::borrow),
15856 encoder, offset + cur_offset, depth
15857 )?;
15858
15859 _prev_end_offset = cur_offset + envelope_size;
15860 if 5 > max_ordinal {
15861 return Ok(());
15862 }
15863
15864 let cur_offset: usize = (5 - 1) * envelope_size;
15867
15868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15870
15871 fidl::encoding::encode_in_envelope_optional::<EncryptionPattern, D>(
15876 self.pattern
15877 .as_ref()
15878 .map(<EncryptionPattern as fidl::encoding::ValueTypeMarker>::borrow),
15879 encoder,
15880 offset + cur_offset,
15881 depth,
15882 )?;
15883
15884 _prev_end_offset = cur_offset + envelope_size;
15885 if 6 > max_ordinal {
15886 return Ok(());
15887 }
15888
15889 let cur_offset: usize = (6 - 1) * envelope_size;
15892
15893 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15895
15896 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
15901 self.scheme.as_ref().map(
15902 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
15903 ),
15904 encoder,
15905 offset + cur_offset,
15906 depth,
15907 )?;
15908
15909 _prev_end_offset = cur_offset + envelope_size;
15910 if 8 > max_ordinal {
15911 return Ok(());
15912 }
15913
15914 let cur_offset: usize = (8 - 1) * envelope_size;
15917
15918 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15920
15921 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15926 self.key_id.as_ref().map(
15927 <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15928 ),
15929 encoder,
15930 offset + cur_offset,
15931 depth,
15932 )?;
15933
15934 _prev_end_offset = cur_offset + envelope_size;
15935
15936 Ok(())
15937 }
15938 }
15939
15940 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptedFormat {
15941 #[inline(always)]
15942 fn new_empty() -> Self {
15943 Self::default()
15944 }
15945
15946 unsafe fn decode(
15947 &mut self,
15948 decoder: &mut fidl::encoding::Decoder<'_, D>,
15949 offset: usize,
15950 mut depth: fidl::encoding::Depth,
15951 ) -> fidl::Result<()> {
15952 decoder.debug_check_bounds::<Self>(offset);
15953 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15954 None => return Err(fidl::Error::NotNullable),
15955 Some(len) => len,
15956 };
15957 if len == 0 {
15959 return Ok(());
15960 };
15961 depth.increment()?;
15962 let envelope_size = 8;
15963 let bytes_len = len * envelope_size;
15964 let offset = decoder.out_of_line_offset(bytes_len)?;
15965 let mut _next_ordinal_to_read = 0;
15967 let mut next_offset = offset;
15968 let end_offset = offset + bytes_len;
15969 _next_ordinal_to_read += 1;
15970 if next_offset >= end_offset {
15971 return Ok(());
15972 }
15973
15974 while _next_ordinal_to_read < 3 {
15976 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15977 _next_ordinal_to_read += 1;
15978 next_offset += envelope_size;
15979 }
15980
15981 let next_out_of_line = decoder.next_out_of_line();
15982 let handles_before = decoder.remaining_handles();
15983 if let Some((inlined, num_bytes, num_handles)) =
15984 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15985 {
15986 let member_inline_size =
15987 <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
15988 decoder.context,
15989 );
15990 if inlined != (member_inline_size <= 4) {
15991 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15992 }
15993 let inner_offset;
15994 let mut inner_depth = depth.clone();
15995 if inlined {
15996 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15997 inner_offset = next_offset;
15998 } else {
15999 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16000 inner_depth.increment()?;
16001 }
16002 let val_ref = self
16003 .init_vector
16004 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
16005 fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
16006 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16007 {
16008 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16009 }
16010 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16011 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16012 }
16013 }
16014
16015 next_offset += envelope_size;
16016 _next_ordinal_to_read += 1;
16017 if next_offset >= end_offset {
16018 return Ok(());
16019 }
16020
16021 while _next_ordinal_to_read < 4 {
16023 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16024 _next_ordinal_to_read += 1;
16025 next_offset += envelope_size;
16026 }
16027
16028 let next_out_of_line = decoder.next_out_of_line();
16029 let handles_before = decoder.remaining_handles();
16030 if let Some((inlined, num_bytes, num_handles)) =
16031 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16032 {
16033 let member_inline_size = <fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16034 if inlined != (member_inline_size <= 4) {
16035 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16036 }
16037 let inner_offset;
16038 let mut inner_depth = depth.clone();
16039 if inlined {
16040 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16041 inner_offset = next_offset;
16042 } else {
16043 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16044 inner_depth.increment()?;
16045 }
16046 let val_ref = self.subsamples.get_or_insert_with(|| {
16047 fidl::new_empty!(fidl::encoding::UnboundedVector<SubsampleEntry>, D)
16048 });
16049 fidl::decode!(
16050 fidl::encoding::UnboundedVector<SubsampleEntry>,
16051 D,
16052 val_ref,
16053 decoder,
16054 inner_offset,
16055 inner_depth
16056 )?;
16057 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16058 {
16059 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16060 }
16061 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16062 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16063 }
16064 }
16065
16066 next_offset += envelope_size;
16067 _next_ordinal_to_read += 1;
16068 if next_offset >= end_offset {
16069 return Ok(());
16070 }
16071
16072 while _next_ordinal_to_read < 5 {
16074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16075 _next_ordinal_to_read += 1;
16076 next_offset += envelope_size;
16077 }
16078
16079 let next_out_of_line = decoder.next_out_of_line();
16080 let handles_before = decoder.remaining_handles();
16081 if let Some((inlined, num_bytes, num_handles)) =
16082 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16083 {
16084 let member_inline_size =
16085 <EncryptionPattern as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16086 if inlined != (member_inline_size <= 4) {
16087 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16088 }
16089 let inner_offset;
16090 let mut inner_depth = depth.clone();
16091 if inlined {
16092 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16093 inner_offset = next_offset;
16094 } else {
16095 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16096 inner_depth.increment()?;
16097 }
16098 let val_ref =
16099 self.pattern.get_or_insert_with(|| fidl::new_empty!(EncryptionPattern, D));
16100 fidl::decode!(EncryptionPattern, D, val_ref, decoder, inner_offset, inner_depth)?;
16101 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16102 {
16103 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16104 }
16105 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16106 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16107 }
16108 }
16109
16110 next_offset += envelope_size;
16111 _next_ordinal_to_read += 1;
16112 if next_offset >= end_offset {
16113 return Ok(());
16114 }
16115
16116 while _next_ordinal_to_read < 6 {
16118 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16119 _next_ordinal_to_read += 1;
16120 next_offset += envelope_size;
16121 }
16122
16123 let next_out_of_line = decoder.next_out_of_line();
16124 let handles_before = decoder.remaining_handles();
16125 if let Some((inlined, num_bytes, num_handles)) =
16126 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16127 {
16128 let member_inline_size =
16129 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
16130 decoder.context,
16131 );
16132 if inlined != (member_inline_size <= 4) {
16133 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16134 }
16135 let inner_offset;
16136 let mut inner_depth = depth.clone();
16137 if inlined {
16138 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16139 inner_offset = next_offset;
16140 } else {
16141 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16142 inner_depth.increment()?;
16143 }
16144 let val_ref = self
16145 .scheme
16146 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
16147 fidl::decode!(
16148 fidl::encoding::UnboundedString,
16149 D,
16150 val_ref,
16151 decoder,
16152 inner_offset,
16153 inner_depth
16154 )?;
16155 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16156 {
16157 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16158 }
16159 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16160 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16161 }
16162 }
16163
16164 next_offset += envelope_size;
16165 _next_ordinal_to_read += 1;
16166 if next_offset >= end_offset {
16167 return Ok(());
16168 }
16169
16170 while _next_ordinal_to_read < 8 {
16172 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16173 _next_ordinal_to_read += 1;
16174 next_offset += envelope_size;
16175 }
16176
16177 let next_out_of_line = decoder.next_out_of_line();
16178 let handles_before = decoder.remaining_handles();
16179 if let Some((inlined, num_bytes, num_handles)) =
16180 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16181 {
16182 let member_inline_size =
16183 <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
16184 decoder.context,
16185 );
16186 if inlined != (member_inline_size <= 4) {
16187 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16188 }
16189 let inner_offset;
16190 let mut inner_depth = depth.clone();
16191 if inlined {
16192 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16193 inner_offset = next_offset;
16194 } else {
16195 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16196 inner_depth.increment()?;
16197 }
16198 let val_ref = self
16199 .key_id
16200 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
16201 fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
16202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16203 {
16204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16205 }
16206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16208 }
16209 }
16210
16211 next_offset += envelope_size;
16212
16213 while next_offset < end_offset {
16215 _next_ordinal_to_read += 1;
16216 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16217 next_offset += envelope_size;
16218 }
16219
16220 Ok(())
16221 }
16222 }
16223
16224 impl FormatDetails {
16225 #[inline(always)]
16226 fn max_ordinal_present(&self) -> u64 {
16227 if let Some(_) = self.profile {
16228 return 8;
16229 }
16230 if let Some(_) = self.timebase {
16231 return 7;
16232 }
16233 if let Some(_) = self.encoder_settings {
16234 return 6;
16235 }
16236 if let Some(_) = self.pass_through_parameters {
16237 return 5;
16238 }
16239 if let Some(_) = self.domain {
16240 return 4;
16241 }
16242 if let Some(_) = self.oob_bytes {
16243 return 3;
16244 }
16245 if let Some(_) = self.mime_type {
16246 return 2;
16247 }
16248 if let Some(_) = self.format_details_version_ordinal {
16249 return 1;
16250 }
16251 0
16252 }
16253 }
16254
16255 impl fidl::encoding::ValueTypeMarker for FormatDetails {
16256 type Borrowed<'a> = &'a Self;
16257 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16258 value
16259 }
16260 }
16261
16262 unsafe impl fidl::encoding::TypeMarker for FormatDetails {
16263 type Owned = Self;
16264
16265 #[inline(always)]
16266 fn inline_align(_context: fidl::encoding::Context) -> usize {
16267 8
16268 }
16269
16270 #[inline(always)]
16271 fn inline_size(_context: fidl::encoding::Context) -> usize {
16272 16
16273 }
16274 }
16275
16276 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatDetails, D>
16277 for &FormatDetails
16278 {
16279 unsafe fn encode(
16280 self,
16281 encoder: &mut fidl::encoding::Encoder<'_, D>,
16282 offset: usize,
16283 mut depth: fidl::encoding::Depth,
16284 ) -> fidl::Result<()> {
16285 encoder.debug_check_bounds::<FormatDetails>(offset);
16286 let max_ordinal: u64 = self.max_ordinal_present();
16288 encoder.write_num(max_ordinal, offset);
16289 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16290 if max_ordinal == 0 {
16292 return Ok(());
16293 }
16294 depth.increment()?;
16295 let envelope_size = 8;
16296 let bytes_len = max_ordinal as usize * envelope_size;
16297 #[allow(unused_variables)]
16298 let offset = encoder.out_of_line_offset(bytes_len);
16299 let mut _prev_end_offset: usize = 0;
16300 if 1 > max_ordinal {
16301 return Ok(());
16302 }
16303
16304 let cur_offset: usize = (1 - 1) * envelope_size;
16307
16308 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16310
16311 fidl::encoding::encode_in_envelope_optional::<u64, D>(
16316 self.format_details_version_ordinal
16317 .as_ref()
16318 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16319 encoder,
16320 offset + cur_offset,
16321 depth,
16322 )?;
16323
16324 _prev_end_offset = cur_offset + envelope_size;
16325 if 2 > max_ordinal {
16326 return Ok(());
16327 }
16328
16329 let cur_offset: usize = (2 - 1) * envelope_size;
16332
16333 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16335
16336 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
16341 self.mime_type.as_ref().map(
16342 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
16343 ),
16344 encoder,
16345 offset + cur_offset,
16346 depth,
16347 )?;
16348
16349 _prev_end_offset = cur_offset + envelope_size;
16350 if 3 > max_ordinal {
16351 return Ok(());
16352 }
16353
16354 let cur_offset: usize = (3 - 1) * envelope_size;
16357
16358 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16360
16361 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
16366 self.oob_bytes.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
16367 encoder, offset + cur_offset, depth
16368 )?;
16369
16370 _prev_end_offset = cur_offset + envelope_size;
16371 if 4 > max_ordinal {
16372 return Ok(());
16373 }
16374
16375 let cur_offset: usize = (4 - 1) * envelope_size;
16378
16379 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16381
16382 fidl::encoding::encode_in_envelope_optional::<DomainFormat, D>(
16387 self.domain.as_ref().map(<DomainFormat as fidl::encoding::ValueTypeMarker>::borrow),
16388 encoder,
16389 offset + cur_offset,
16390 depth,
16391 )?;
16392
16393 _prev_end_offset = cur_offset + envelope_size;
16394 if 5 > max_ordinal {
16395 return Ok(());
16396 }
16397
16398 let cur_offset: usize = (5 - 1) * envelope_size;
16401
16402 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16404
16405 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Parameter>, D>(
16410 self.pass_through_parameters.as_ref().map(<fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::ValueTypeMarker>::borrow),
16411 encoder, offset + cur_offset, depth
16412 )?;
16413
16414 _prev_end_offset = cur_offset + envelope_size;
16415 if 6 > max_ordinal {
16416 return Ok(());
16417 }
16418
16419 let cur_offset: usize = (6 - 1) * envelope_size;
16422
16423 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16425
16426 fidl::encoding::encode_in_envelope_optional::<EncoderSettings, D>(
16431 self.encoder_settings
16432 .as_ref()
16433 .map(<EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow),
16434 encoder,
16435 offset + cur_offset,
16436 depth,
16437 )?;
16438
16439 _prev_end_offset = cur_offset + envelope_size;
16440 if 7 > max_ordinal {
16441 return Ok(());
16442 }
16443
16444 let cur_offset: usize = (7 - 1) * envelope_size;
16447
16448 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16450
16451 fidl::encoding::encode_in_envelope_optional::<u64, D>(
16456 self.timebase.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16457 encoder,
16458 offset + cur_offset,
16459 depth,
16460 )?;
16461
16462 _prev_end_offset = cur_offset + envelope_size;
16463 if 8 > max_ordinal {
16464 return Ok(());
16465 }
16466
16467 let cur_offset: usize = (8 - 1) * envelope_size;
16470
16471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16473
16474 fidl::encoding::encode_in_envelope_optional::<CodecProfile, D>(
16479 self.profile
16480 .as_ref()
16481 .map(<CodecProfile as fidl::encoding::ValueTypeMarker>::borrow),
16482 encoder,
16483 offset + cur_offset,
16484 depth,
16485 )?;
16486
16487 _prev_end_offset = cur_offset + envelope_size;
16488
16489 Ok(())
16490 }
16491 }
16492
16493 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatDetails {
16494 #[inline(always)]
16495 fn new_empty() -> Self {
16496 Self::default()
16497 }
16498
16499 unsafe fn decode(
16500 &mut self,
16501 decoder: &mut fidl::encoding::Decoder<'_, D>,
16502 offset: usize,
16503 mut depth: fidl::encoding::Depth,
16504 ) -> fidl::Result<()> {
16505 decoder.debug_check_bounds::<Self>(offset);
16506 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16507 None => return Err(fidl::Error::NotNullable),
16508 Some(len) => len,
16509 };
16510 if len == 0 {
16512 return Ok(());
16513 };
16514 depth.increment()?;
16515 let envelope_size = 8;
16516 let bytes_len = len * envelope_size;
16517 let offset = decoder.out_of_line_offset(bytes_len)?;
16518 let mut _next_ordinal_to_read = 0;
16520 let mut next_offset = offset;
16521 let end_offset = offset + bytes_len;
16522 _next_ordinal_to_read += 1;
16523 if next_offset >= end_offset {
16524 return Ok(());
16525 }
16526
16527 while _next_ordinal_to_read < 1 {
16529 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16530 _next_ordinal_to_read += 1;
16531 next_offset += envelope_size;
16532 }
16533
16534 let next_out_of_line = decoder.next_out_of_line();
16535 let handles_before = decoder.remaining_handles();
16536 if let Some((inlined, num_bytes, num_handles)) =
16537 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16538 {
16539 let member_inline_size =
16540 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16541 if inlined != (member_inline_size <= 4) {
16542 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16543 }
16544 let inner_offset;
16545 let mut inner_depth = depth.clone();
16546 if inlined {
16547 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16548 inner_offset = next_offset;
16549 } else {
16550 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16551 inner_depth.increment()?;
16552 }
16553 let val_ref = self
16554 .format_details_version_ordinal
16555 .get_or_insert_with(|| fidl::new_empty!(u64, D));
16556 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16557 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16558 {
16559 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16560 }
16561 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16562 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16563 }
16564 }
16565
16566 next_offset += envelope_size;
16567 _next_ordinal_to_read += 1;
16568 if next_offset >= end_offset {
16569 return Ok(());
16570 }
16571
16572 while _next_ordinal_to_read < 2 {
16574 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16575 _next_ordinal_to_read += 1;
16576 next_offset += envelope_size;
16577 }
16578
16579 let next_out_of_line = decoder.next_out_of_line();
16580 let handles_before = decoder.remaining_handles();
16581 if let Some((inlined, num_bytes, num_handles)) =
16582 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16583 {
16584 let member_inline_size =
16585 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
16586 decoder.context,
16587 );
16588 if inlined != (member_inline_size <= 4) {
16589 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16590 }
16591 let inner_offset;
16592 let mut inner_depth = depth.clone();
16593 if inlined {
16594 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16595 inner_offset = next_offset;
16596 } else {
16597 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16598 inner_depth.increment()?;
16599 }
16600 let val_ref = self
16601 .mime_type
16602 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
16603 fidl::decode!(
16604 fidl::encoding::UnboundedString,
16605 D,
16606 val_ref,
16607 decoder,
16608 inner_offset,
16609 inner_depth
16610 )?;
16611 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16612 {
16613 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16614 }
16615 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16616 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16617 }
16618 }
16619
16620 next_offset += envelope_size;
16621 _next_ordinal_to_read += 1;
16622 if next_offset >= end_offset {
16623 return Ok(());
16624 }
16625
16626 while _next_ordinal_to_read < 3 {
16628 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16629 _next_ordinal_to_read += 1;
16630 next_offset += envelope_size;
16631 }
16632
16633 let next_out_of_line = decoder.next_out_of_line();
16634 let handles_before = decoder.remaining_handles();
16635 if let Some((inlined, num_bytes, num_handles)) =
16636 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16637 {
16638 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16639 if inlined != (member_inline_size <= 4) {
16640 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16641 }
16642 let inner_offset;
16643 let mut inner_depth = depth.clone();
16644 if inlined {
16645 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16646 inner_offset = next_offset;
16647 } else {
16648 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16649 inner_depth.increment()?;
16650 }
16651 let val_ref = self.oob_bytes.get_or_insert_with(|| {
16652 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
16653 });
16654 fidl::decode!(
16655 fidl::encoding::UnboundedVector<u8>,
16656 D,
16657 val_ref,
16658 decoder,
16659 inner_offset,
16660 inner_depth
16661 )?;
16662 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16663 {
16664 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16665 }
16666 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16667 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16668 }
16669 }
16670
16671 next_offset += envelope_size;
16672 _next_ordinal_to_read += 1;
16673 if next_offset >= end_offset {
16674 return Ok(());
16675 }
16676
16677 while _next_ordinal_to_read < 4 {
16679 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16680 _next_ordinal_to_read += 1;
16681 next_offset += envelope_size;
16682 }
16683
16684 let next_out_of_line = decoder.next_out_of_line();
16685 let handles_before = decoder.remaining_handles();
16686 if let Some((inlined, num_bytes, num_handles)) =
16687 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16688 {
16689 let member_inline_size =
16690 <DomainFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16691 if inlined != (member_inline_size <= 4) {
16692 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16693 }
16694 let inner_offset;
16695 let mut inner_depth = depth.clone();
16696 if inlined {
16697 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16698 inner_offset = next_offset;
16699 } else {
16700 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16701 inner_depth.increment()?;
16702 }
16703 let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(DomainFormat, D));
16704 fidl::decode!(DomainFormat, D, val_ref, decoder, inner_offset, inner_depth)?;
16705 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16706 {
16707 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16708 }
16709 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16710 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16711 }
16712 }
16713
16714 next_offset += envelope_size;
16715 _next_ordinal_to_read += 1;
16716 if next_offset >= end_offset {
16717 return Ok(());
16718 }
16719
16720 while _next_ordinal_to_read < 5 {
16722 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16723 _next_ordinal_to_read += 1;
16724 next_offset += envelope_size;
16725 }
16726
16727 let next_out_of_line = decoder.next_out_of_line();
16728 let handles_before = decoder.remaining_handles();
16729 if let Some((inlined, num_bytes, num_handles)) =
16730 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16731 {
16732 let member_inline_size = <fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16733 if inlined != (member_inline_size <= 4) {
16734 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16735 }
16736 let inner_offset;
16737 let mut inner_depth = depth.clone();
16738 if inlined {
16739 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16740 inner_offset = next_offset;
16741 } else {
16742 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16743 inner_depth.increment()?;
16744 }
16745 let val_ref = self.pass_through_parameters.get_or_insert_with(|| {
16746 fidl::new_empty!(fidl::encoding::UnboundedVector<Parameter>, D)
16747 });
16748 fidl::decode!(
16749 fidl::encoding::UnboundedVector<Parameter>,
16750 D,
16751 val_ref,
16752 decoder,
16753 inner_offset,
16754 inner_depth
16755 )?;
16756 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16757 {
16758 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16759 }
16760 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16761 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16762 }
16763 }
16764
16765 next_offset += envelope_size;
16766 _next_ordinal_to_read += 1;
16767 if next_offset >= end_offset {
16768 return Ok(());
16769 }
16770
16771 while _next_ordinal_to_read < 6 {
16773 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16774 _next_ordinal_to_read += 1;
16775 next_offset += envelope_size;
16776 }
16777
16778 let next_out_of_line = decoder.next_out_of_line();
16779 let handles_before = decoder.remaining_handles();
16780 if let Some((inlined, num_bytes, num_handles)) =
16781 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16782 {
16783 let member_inline_size =
16784 <EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16785 if inlined != (member_inline_size <= 4) {
16786 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16787 }
16788 let inner_offset;
16789 let mut inner_depth = depth.clone();
16790 if inlined {
16791 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16792 inner_offset = next_offset;
16793 } else {
16794 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16795 inner_depth.increment()?;
16796 }
16797 let val_ref = self
16798 .encoder_settings
16799 .get_or_insert_with(|| fidl::new_empty!(EncoderSettings, D));
16800 fidl::decode!(EncoderSettings, D, val_ref, decoder, inner_offset, inner_depth)?;
16801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16802 {
16803 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16804 }
16805 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16806 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16807 }
16808 }
16809
16810 next_offset += envelope_size;
16811 _next_ordinal_to_read += 1;
16812 if next_offset >= end_offset {
16813 return Ok(());
16814 }
16815
16816 while _next_ordinal_to_read < 7 {
16818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16819 _next_ordinal_to_read += 1;
16820 next_offset += envelope_size;
16821 }
16822
16823 let next_out_of_line = decoder.next_out_of_line();
16824 let handles_before = decoder.remaining_handles();
16825 if let Some((inlined, num_bytes, num_handles)) =
16826 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16827 {
16828 let member_inline_size =
16829 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16830 if inlined != (member_inline_size <= 4) {
16831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16832 }
16833 let inner_offset;
16834 let mut inner_depth = depth.clone();
16835 if inlined {
16836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16837 inner_offset = next_offset;
16838 } else {
16839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16840 inner_depth.increment()?;
16841 }
16842 let val_ref = self.timebase.get_or_insert_with(|| fidl::new_empty!(u64, D));
16843 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16845 {
16846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16847 }
16848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16850 }
16851 }
16852
16853 next_offset += envelope_size;
16854 _next_ordinal_to_read += 1;
16855 if next_offset >= end_offset {
16856 return Ok(());
16857 }
16858
16859 while _next_ordinal_to_read < 8 {
16861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16862 _next_ordinal_to_read += 1;
16863 next_offset += envelope_size;
16864 }
16865
16866 let next_out_of_line = decoder.next_out_of_line();
16867 let handles_before = decoder.remaining_handles();
16868 if let Some((inlined, num_bytes, num_handles)) =
16869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16870 {
16871 let member_inline_size =
16872 <CodecProfile as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16873 if inlined != (member_inline_size <= 4) {
16874 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16875 }
16876 let inner_offset;
16877 let mut inner_depth = depth.clone();
16878 if inlined {
16879 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16880 inner_offset = next_offset;
16881 } else {
16882 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16883 inner_depth.increment()?;
16884 }
16885 let val_ref = self.profile.get_or_insert_with(|| fidl::new_empty!(CodecProfile, D));
16886 fidl::decode!(CodecProfile, D, val_ref, decoder, inner_offset, inner_depth)?;
16887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16888 {
16889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16890 }
16891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16893 }
16894 }
16895
16896 next_offset += envelope_size;
16897
16898 while next_offset < end_offset {
16900 _next_ordinal_to_read += 1;
16901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16902 next_offset += envelope_size;
16903 }
16904
16905 Ok(())
16906 }
16907 }
16908
16909 impl H264EncoderSettings {
16910 #[inline(always)]
16911 fn max_ordinal_present(&self) -> u64 {
16912 if let Some(_) = self.quantization_params {
16913 return 7;
16914 }
16915 if let Some(_) = self.force_key_frame {
16916 return 6;
16917 }
16918 if let Some(_) = self.min_frame_rate {
16919 return 5;
16920 }
16921 if let Some(_) = self.variable_frame_rate {
16922 return 4;
16923 }
16924 if let Some(_) = self.gop_size {
16925 return 3;
16926 }
16927 if let Some(_) = self.frame_rate {
16928 return 2;
16929 }
16930 if let Some(_) = self.bit_rate {
16931 return 1;
16932 }
16933 0
16934 }
16935 }
16936
16937 impl fidl::encoding::ValueTypeMarker for H264EncoderSettings {
16938 type Borrowed<'a> = &'a Self;
16939 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16940 value
16941 }
16942 }
16943
16944 unsafe impl fidl::encoding::TypeMarker for H264EncoderSettings {
16945 type Owned = Self;
16946
16947 #[inline(always)]
16948 fn inline_align(_context: fidl::encoding::Context) -> usize {
16949 8
16950 }
16951
16952 #[inline(always)]
16953 fn inline_size(_context: fidl::encoding::Context) -> usize {
16954 16
16955 }
16956 }
16957
16958 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<H264EncoderSettings, D>
16959 for &H264EncoderSettings
16960 {
16961 unsafe fn encode(
16962 self,
16963 encoder: &mut fidl::encoding::Encoder<'_, D>,
16964 offset: usize,
16965 mut depth: fidl::encoding::Depth,
16966 ) -> fidl::Result<()> {
16967 encoder.debug_check_bounds::<H264EncoderSettings>(offset);
16968 let max_ordinal: u64 = self.max_ordinal_present();
16970 encoder.write_num(max_ordinal, offset);
16971 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16972 if max_ordinal == 0 {
16974 return Ok(());
16975 }
16976 depth.increment()?;
16977 let envelope_size = 8;
16978 let bytes_len = max_ordinal as usize * envelope_size;
16979 #[allow(unused_variables)]
16980 let offset = encoder.out_of_line_offset(bytes_len);
16981 let mut _prev_end_offset: usize = 0;
16982 if 1 > max_ordinal {
16983 return Ok(());
16984 }
16985
16986 let cur_offset: usize = (1 - 1) * envelope_size;
16989
16990 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16992
16993 fidl::encoding::encode_in_envelope_optional::<u32, D>(
16998 self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16999 encoder,
17000 offset + cur_offset,
17001 depth,
17002 )?;
17003
17004 _prev_end_offset = cur_offset + envelope_size;
17005 if 2 > max_ordinal {
17006 return Ok(());
17007 }
17008
17009 let cur_offset: usize = (2 - 1) * envelope_size;
17012
17013 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17015
17016 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17021 self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17022 encoder,
17023 offset + cur_offset,
17024 depth,
17025 )?;
17026
17027 _prev_end_offset = cur_offset + envelope_size;
17028 if 3 > max_ordinal {
17029 return Ok(());
17030 }
17031
17032 let cur_offset: usize = (3 - 1) * envelope_size;
17035
17036 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17038
17039 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17044 self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17045 encoder,
17046 offset + cur_offset,
17047 depth,
17048 )?;
17049
17050 _prev_end_offset = cur_offset + envelope_size;
17051 if 4 > max_ordinal {
17052 return Ok(());
17053 }
17054
17055 let cur_offset: usize = (4 - 1) * envelope_size;
17058
17059 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17061
17062 fidl::encoding::encode_in_envelope_optional::<bool, D>(
17067 self.variable_frame_rate
17068 .as_ref()
17069 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
17070 encoder,
17071 offset + cur_offset,
17072 depth,
17073 )?;
17074
17075 _prev_end_offset = cur_offset + envelope_size;
17076 if 5 > max_ordinal {
17077 return Ok(());
17078 }
17079
17080 let cur_offset: usize = (5 - 1) * envelope_size;
17083
17084 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17086
17087 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17092 self.min_frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17093 encoder,
17094 offset + cur_offset,
17095 depth,
17096 )?;
17097
17098 _prev_end_offset = cur_offset + envelope_size;
17099 if 6 > max_ordinal {
17100 return Ok(());
17101 }
17102
17103 let cur_offset: usize = (6 - 1) * envelope_size;
17106
17107 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17109
17110 fidl::encoding::encode_in_envelope_optional::<bool, D>(
17115 self.force_key_frame
17116 .as_ref()
17117 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
17118 encoder,
17119 offset + cur_offset,
17120 depth,
17121 )?;
17122
17123 _prev_end_offset = cur_offset + envelope_size;
17124 if 7 > max_ordinal {
17125 return Ok(());
17126 }
17127
17128 let cur_offset: usize = (7 - 1) * envelope_size;
17131
17132 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17134
17135 fidl::encoding::encode_in_envelope_optional::<H264QuantizationParameters, D>(
17140 self.quantization_params
17141 .as_ref()
17142 .map(<H264QuantizationParameters as fidl::encoding::ValueTypeMarker>::borrow),
17143 encoder,
17144 offset + cur_offset,
17145 depth,
17146 )?;
17147
17148 _prev_end_offset = cur_offset + envelope_size;
17149
17150 Ok(())
17151 }
17152 }
17153
17154 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for H264EncoderSettings {
17155 #[inline(always)]
17156 fn new_empty() -> Self {
17157 Self::default()
17158 }
17159
17160 unsafe fn decode(
17161 &mut self,
17162 decoder: &mut fidl::encoding::Decoder<'_, D>,
17163 offset: usize,
17164 mut depth: fidl::encoding::Depth,
17165 ) -> fidl::Result<()> {
17166 decoder.debug_check_bounds::<Self>(offset);
17167 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17168 None => return Err(fidl::Error::NotNullable),
17169 Some(len) => len,
17170 };
17171 if len == 0 {
17173 return Ok(());
17174 };
17175 depth.increment()?;
17176 let envelope_size = 8;
17177 let bytes_len = len * envelope_size;
17178 let offset = decoder.out_of_line_offset(bytes_len)?;
17179 let mut _next_ordinal_to_read = 0;
17181 let mut next_offset = offset;
17182 let end_offset = offset + bytes_len;
17183 _next_ordinal_to_read += 1;
17184 if next_offset >= end_offset {
17185 return Ok(());
17186 }
17187
17188 while _next_ordinal_to_read < 1 {
17190 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17191 _next_ordinal_to_read += 1;
17192 next_offset += envelope_size;
17193 }
17194
17195 let next_out_of_line = decoder.next_out_of_line();
17196 let handles_before = decoder.remaining_handles();
17197 if let Some((inlined, num_bytes, num_handles)) =
17198 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17199 {
17200 let member_inline_size =
17201 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17202 if inlined != (member_inline_size <= 4) {
17203 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17204 }
17205 let inner_offset;
17206 let mut inner_depth = depth.clone();
17207 if inlined {
17208 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17209 inner_offset = next_offset;
17210 } else {
17211 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17212 inner_depth.increment()?;
17213 }
17214 let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17215 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17216 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17217 {
17218 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17219 }
17220 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17221 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17222 }
17223 }
17224
17225 next_offset += envelope_size;
17226 _next_ordinal_to_read += 1;
17227 if next_offset >= end_offset {
17228 return Ok(());
17229 }
17230
17231 while _next_ordinal_to_read < 2 {
17233 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17234 _next_ordinal_to_read += 1;
17235 next_offset += envelope_size;
17236 }
17237
17238 let next_out_of_line = decoder.next_out_of_line();
17239 let handles_before = decoder.remaining_handles();
17240 if let Some((inlined, num_bytes, num_handles)) =
17241 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17242 {
17243 let member_inline_size =
17244 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17245 if inlined != (member_inline_size <= 4) {
17246 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17247 }
17248 let inner_offset;
17249 let mut inner_depth = depth.clone();
17250 if inlined {
17251 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17252 inner_offset = next_offset;
17253 } else {
17254 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17255 inner_depth.increment()?;
17256 }
17257 let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17258 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17259 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17260 {
17261 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17262 }
17263 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17264 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17265 }
17266 }
17267
17268 next_offset += envelope_size;
17269 _next_ordinal_to_read += 1;
17270 if next_offset >= end_offset {
17271 return Ok(());
17272 }
17273
17274 while _next_ordinal_to_read < 3 {
17276 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17277 _next_ordinal_to_read += 1;
17278 next_offset += envelope_size;
17279 }
17280
17281 let next_out_of_line = decoder.next_out_of_line();
17282 let handles_before = decoder.remaining_handles();
17283 if let Some((inlined, num_bytes, num_handles)) =
17284 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17285 {
17286 let member_inline_size =
17287 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17288 if inlined != (member_inline_size <= 4) {
17289 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17290 }
17291 let inner_offset;
17292 let mut inner_depth = depth.clone();
17293 if inlined {
17294 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17295 inner_offset = next_offset;
17296 } else {
17297 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17298 inner_depth.increment()?;
17299 }
17300 let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
17301 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17302 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17303 {
17304 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17305 }
17306 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17307 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17308 }
17309 }
17310
17311 next_offset += envelope_size;
17312 _next_ordinal_to_read += 1;
17313 if next_offset >= end_offset {
17314 return Ok(());
17315 }
17316
17317 while _next_ordinal_to_read < 4 {
17319 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17320 _next_ordinal_to_read += 1;
17321 next_offset += envelope_size;
17322 }
17323
17324 let next_out_of_line = decoder.next_out_of_line();
17325 let handles_before = decoder.remaining_handles();
17326 if let Some((inlined, num_bytes, num_handles)) =
17327 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17328 {
17329 let member_inline_size =
17330 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17331 if inlined != (member_inline_size <= 4) {
17332 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17333 }
17334 let inner_offset;
17335 let mut inner_depth = depth.clone();
17336 if inlined {
17337 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17338 inner_offset = next_offset;
17339 } else {
17340 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17341 inner_depth.increment()?;
17342 }
17343 let val_ref =
17344 self.variable_frame_rate.get_or_insert_with(|| fidl::new_empty!(bool, D));
17345 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17346 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17347 {
17348 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17349 }
17350 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17351 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17352 }
17353 }
17354
17355 next_offset += envelope_size;
17356 _next_ordinal_to_read += 1;
17357 if next_offset >= end_offset {
17358 return Ok(());
17359 }
17360
17361 while _next_ordinal_to_read < 5 {
17363 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17364 _next_ordinal_to_read += 1;
17365 next_offset += envelope_size;
17366 }
17367
17368 let next_out_of_line = decoder.next_out_of_line();
17369 let handles_before = decoder.remaining_handles();
17370 if let Some((inlined, num_bytes, num_handles)) =
17371 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17372 {
17373 let member_inline_size =
17374 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17375 if inlined != (member_inline_size <= 4) {
17376 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17377 }
17378 let inner_offset;
17379 let mut inner_depth = depth.clone();
17380 if inlined {
17381 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17382 inner_offset = next_offset;
17383 } else {
17384 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17385 inner_depth.increment()?;
17386 }
17387 let val_ref = self.min_frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17388 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17389 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17390 {
17391 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17392 }
17393 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17394 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17395 }
17396 }
17397
17398 next_offset += envelope_size;
17399 _next_ordinal_to_read += 1;
17400 if next_offset >= end_offset {
17401 return Ok(());
17402 }
17403
17404 while _next_ordinal_to_read < 6 {
17406 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17407 _next_ordinal_to_read += 1;
17408 next_offset += envelope_size;
17409 }
17410
17411 let next_out_of_line = decoder.next_out_of_line();
17412 let handles_before = decoder.remaining_handles();
17413 if let Some((inlined, num_bytes, num_handles)) =
17414 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17415 {
17416 let member_inline_size =
17417 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17418 if inlined != (member_inline_size <= 4) {
17419 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17420 }
17421 let inner_offset;
17422 let mut inner_depth = depth.clone();
17423 if inlined {
17424 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17425 inner_offset = next_offset;
17426 } else {
17427 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17428 inner_depth.increment()?;
17429 }
17430 let val_ref = self.force_key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
17431 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17432 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17433 {
17434 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17435 }
17436 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17437 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17438 }
17439 }
17440
17441 next_offset += envelope_size;
17442 _next_ordinal_to_read += 1;
17443 if next_offset >= end_offset {
17444 return Ok(());
17445 }
17446
17447 while _next_ordinal_to_read < 7 {
17449 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17450 _next_ordinal_to_read += 1;
17451 next_offset += envelope_size;
17452 }
17453
17454 let next_out_of_line = decoder.next_out_of_line();
17455 let handles_before = decoder.remaining_handles();
17456 if let Some((inlined, num_bytes, num_handles)) =
17457 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17458 {
17459 let member_inline_size =
17460 <H264QuantizationParameters as fidl::encoding::TypeMarker>::inline_size(
17461 decoder.context,
17462 );
17463 if inlined != (member_inline_size <= 4) {
17464 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17465 }
17466 let inner_offset;
17467 let mut inner_depth = depth.clone();
17468 if inlined {
17469 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17470 inner_offset = next_offset;
17471 } else {
17472 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17473 inner_depth.increment()?;
17474 }
17475 let val_ref = self
17476 .quantization_params
17477 .get_or_insert_with(|| fidl::new_empty!(H264QuantizationParameters, D));
17478 fidl::decode!(
17479 H264QuantizationParameters,
17480 D,
17481 val_ref,
17482 decoder,
17483 inner_offset,
17484 inner_depth
17485 )?;
17486 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17487 {
17488 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17489 }
17490 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17491 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17492 }
17493 }
17494
17495 next_offset += envelope_size;
17496
17497 while next_offset < end_offset {
17499 _next_ordinal_to_read += 1;
17500 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17501 next_offset += envelope_size;
17502 }
17503
17504 Ok(())
17505 }
17506 }
17507
17508 impl H264QuantizationParameters {
17509 #[inline(always)]
17510 fn max_ordinal_present(&self) -> u64 {
17511 if let Some(_) = self.p_max {
17512 return 6;
17513 }
17514 if let Some(_) = self.p_min {
17515 return 5;
17516 }
17517 if let Some(_) = self.p_base {
17518 return 4;
17519 }
17520 if let Some(_) = self.i_max {
17521 return 3;
17522 }
17523 if let Some(_) = self.i_min {
17524 return 2;
17525 }
17526 if let Some(_) = self.i_base {
17527 return 1;
17528 }
17529 0
17530 }
17531 }
17532
17533 impl fidl::encoding::ValueTypeMarker for H264QuantizationParameters {
17534 type Borrowed<'a> = &'a Self;
17535 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17536 value
17537 }
17538 }
17539
17540 unsafe impl fidl::encoding::TypeMarker for H264QuantizationParameters {
17541 type Owned = Self;
17542
17543 #[inline(always)]
17544 fn inline_align(_context: fidl::encoding::Context) -> usize {
17545 8
17546 }
17547
17548 #[inline(always)]
17549 fn inline_size(_context: fidl::encoding::Context) -> usize {
17550 16
17551 }
17552 }
17553
17554 unsafe impl<D: fidl::encoding::ResourceDialect>
17555 fidl::encoding::Encode<H264QuantizationParameters, D> for &H264QuantizationParameters
17556 {
17557 unsafe fn encode(
17558 self,
17559 encoder: &mut fidl::encoding::Encoder<'_, D>,
17560 offset: usize,
17561 mut depth: fidl::encoding::Depth,
17562 ) -> fidl::Result<()> {
17563 encoder.debug_check_bounds::<H264QuantizationParameters>(offset);
17564 let max_ordinal: u64 = self.max_ordinal_present();
17566 encoder.write_num(max_ordinal, offset);
17567 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17568 if max_ordinal == 0 {
17570 return Ok(());
17571 }
17572 depth.increment()?;
17573 let envelope_size = 8;
17574 let bytes_len = max_ordinal as usize * envelope_size;
17575 #[allow(unused_variables)]
17576 let offset = encoder.out_of_line_offset(bytes_len);
17577 let mut _prev_end_offset: usize = 0;
17578 if 1 > max_ordinal {
17579 return Ok(());
17580 }
17581
17582 let cur_offset: usize = (1 - 1) * envelope_size;
17585
17586 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17588
17589 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17594 self.i_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17595 encoder,
17596 offset + cur_offset,
17597 depth,
17598 )?;
17599
17600 _prev_end_offset = cur_offset + envelope_size;
17601 if 2 > max_ordinal {
17602 return Ok(());
17603 }
17604
17605 let cur_offset: usize = (2 - 1) * envelope_size;
17608
17609 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17611
17612 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17617 self.i_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17618 encoder,
17619 offset + cur_offset,
17620 depth,
17621 )?;
17622
17623 _prev_end_offset = cur_offset + envelope_size;
17624 if 3 > max_ordinal {
17625 return Ok(());
17626 }
17627
17628 let cur_offset: usize = (3 - 1) * envelope_size;
17631
17632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17634
17635 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17640 self.i_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17641 encoder,
17642 offset + cur_offset,
17643 depth,
17644 )?;
17645
17646 _prev_end_offset = cur_offset + envelope_size;
17647 if 4 > max_ordinal {
17648 return Ok(());
17649 }
17650
17651 let cur_offset: usize = (4 - 1) * envelope_size;
17654
17655 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17657
17658 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17663 self.p_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17664 encoder,
17665 offset + cur_offset,
17666 depth,
17667 )?;
17668
17669 _prev_end_offset = cur_offset + envelope_size;
17670 if 5 > max_ordinal {
17671 return Ok(());
17672 }
17673
17674 let cur_offset: usize = (5 - 1) * envelope_size;
17677
17678 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17680
17681 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17686 self.p_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17687 encoder,
17688 offset + cur_offset,
17689 depth,
17690 )?;
17691
17692 _prev_end_offset = cur_offset + envelope_size;
17693 if 6 > max_ordinal {
17694 return Ok(());
17695 }
17696
17697 let cur_offset: usize = (6 - 1) * envelope_size;
17700
17701 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17703
17704 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17709 self.p_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17710 encoder,
17711 offset + cur_offset,
17712 depth,
17713 )?;
17714
17715 _prev_end_offset = cur_offset + envelope_size;
17716
17717 Ok(())
17718 }
17719 }
17720
17721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
17722 for H264QuantizationParameters
17723 {
17724 #[inline(always)]
17725 fn new_empty() -> Self {
17726 Self::default()
17727 }
17728
17729 unsafe fn decode(
17730 &mut self,
17731 decoder: &mut fidl::encoding::Decoder<'_, D>,
17732 offset: usize,
17733 mut depth: fidl::encoding::Depth,
17734 ) -> fidl::Result<()> {
17735 decoder.debug_check_bounds::<Self>(offset);
17736 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17737 None => return Err(fidl::Error::NotNullable),
17738 Some(len) => len,
17739 };
17740 if len == 0 {
17742 return Ok(());
17743 };
17744 depth.increment()?;
17745 let envelope_size = 8;
17746 let bytes_len = len * envelope_size;
17747 let offset = decoder.out_of_line_offset(bytes_len)?;
17748 let mut _next_ordinal_to_read = 0;
17750 let mut next_offset = offset;
17751 let end_offset = offset + bytes_len;
17752 _next_ordinal_to_read += 1;
17753 if next_offset >= end_offset {
17754 return Ok(());
17755 }
17756
17757 while _next_ordinal_to_read < 1 {
17759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17760 _next_ordinal_to_read += 1;
17761 next_offset += envelope_size;
17762 }
17763
17764 let next_out_of_line = decoder.next_out_of_line();
17765 let handles_before = decoder.remaining_handles();
17766 if let Some((inlined, num_bytes, num_handles)) =
17767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17768 {
17769 let member_inline_size =
17770 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17771 if inlined != (member_inline_size <= 4) {
17772 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17773 }
17774 let inner_offset;
17775 let mut inner_depth = depth.clone();
17776 if inlined {
17777 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17778 inner_offset = next_offset;
17779 } else {
17780 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17781 inner_depth.increment()?;
17782 }
17783 let val_ref = self.i_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17784 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17785 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17786 {
17787 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17788 }
17789 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17790 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17791 }
17792 }
17793
17794 next_offset += envelope_size;
17795 _next_ordinal_to_read += 1;
17796 if next_offset >= end_offset {
17797 return Ok(());
17798 }
17799
17800 while _next_ordinal_to_read < 2 {
17802 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17803 _next_ordinal_to_read += 1;
17804 next_offset += envelope_size;
17805 }
17806
17807 let next_out_of_line = decoder.next_out_of_line();
17808 let handles_before = decoder.remaining_handles();
17809 if let Some((inlined, num_bytes, num_handles)) =
17810 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17811 {
17812 let member_inline_size =
17813 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17814 if inlined != (member_inline_size <= 4) {
17815 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17816 }
17817 let inner_offset;
17818 let mut inner_depth = depth.clone();
17819 if inlined {
17820 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17821 inner_offset = next_offset;
17822 } else {
17823 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17824 inner_depth.increment()?;
17825 }
17826 let val_ref = self.i_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17827 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17828 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17829 {
17830 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17831 }
17832 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17833 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17834 }
17835 }
17836
17837 next_offset += envelope_size;
17838 _next_ordinal_to_read += 1;
17839 if next_offset >= end_offset {
17840 return Ok(());
17841 }
17842
17843 while _next_ordinal_to_read < 3 {
17845 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17846 _next_ordinal_to_read += 1;
17847 next_offset += envelope_size;
17848 }
17849
17850 let next_out_of_line = decoder.next_out_of_line();
17851 let handles_before = decoder.remaining_handles();
17852 if let Some((inlined, num_bytes, num_handles)) =
17853 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17854 {
17855 let member_inline_size =
17856 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17857 if inlined != (member_inline_size <= 4) {
17858 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17859 }
17860 let inner_offset;
17861 let mut inner_depth = depth.clone();
17862 if inlined {
17863 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17864 inner_offset = next_offset;
17865 } else {
17866 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17867 inner_depth.increment()?;
17868 }
17869 let val_ref = self.i_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17870 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17872 {
17873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17874 }
17875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17877 }
17878 }
17879
17880 next_offset += envelope_size;
17881 _next_ordinal_to_read += 1;
17882 if next_offset >= end_offset {
17883 return Ok(());
17884 }
17885
17886 while _next_ordinal_to_read < 4 {
17888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17889 _next_ordinal_to_read += 1;
17890 next_offset += envelope_size;
17891 }
17892
17893 let next_out_of_line = decoder.next_out_of_line();
17894 let handles_before = decoder.remaining_handles();
17895 if let Some((inlined, num_bytes, num_handles)) =
17896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17897 {
17898 let member_inline_size =
17899 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17900 if inlined != (member_inline_size <= 4) {
17901 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17902 }
17903 let inner_offset;
17904 let mut inner_depth = depth.clone();
17905 if inlined {
17906 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17907 inner_offset = next_offset;
17908 } else {
17909 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17910 inner_depth.increment()?;
17911 }
17912 let val_ref = self.p_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17913 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17914 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17915 {
17916 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17917 }
17918 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17919 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17920 }
17921 }
17922
17923 next_offset += envelope_size;
17924 _next_ordinal_to_read += 1;
17925 if next_offset >= end_offset {
17926 return Ok(());
17927 }
17928
17929 while _next_ordinal_to_read < 5 {
17931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17932 _next_ordinal_to_read += 1;
17933 next_offset += envelope_size;
17934 }
17935
17936 let next_out_of_line = decoder.next_out_of_line();
17937 let handles_before = decoder.remaining_handles();
17938 if let Some((inlined, num_bytes, num_handles)) =
17939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17940 {
17941 let member_inline_size =
17942 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17943 if inlined != (member_inline_size <= 4) {
17944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17945 }
17946 let inner_offset;
17947 let mut inner_depth = depth.clone();
17948 if inlined {
17949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17950 inner_offset = next_offset;
17951 } else {
17952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17953 inner_depth.increment()?;
17954 }
17955 let val_ref = self.p_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17956 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17958 {
17959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17960 }
17961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17963 }
17964 }
17965
17966 next_offset += envelope_size;
17967 _next_ordinal_to_read += 1;
17968 if next_offset >= end_offset {
17969 return Ok(());
17970 }
17971
17972 while _next_ordinal_to_read < 6 {
17974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17975 _next_ordinal_to_read += 1;
17976 next_offset += envelope_size;
17977 }
17978
17979 let next_out_of_line = decoder.next_out_of_line();
17980 let handles_before = decoder.remaining_handles();
17981 if let Some((inlined, num_bytes, num_handles)) =
17982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17983 {
17984 let member_inline_size =
17985 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17986 if inlined != (member_inline_size <= 4) {
17987 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17988 }
17989 let inner_offset;
17990 let mut inner_depth = depth.clone();
17991 if inlined {
17992 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17993 inner_offset = next_offset;
17994 } else {
17995 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17996 inner_depth.increment()?;
17997 }
17998 let val_ref = self.p_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17999 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18000 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18001 {
18002 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18003 }
18004 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18005 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18006 }
18007 }
18008
18009 next_offset += envelope_size;
18010
18011 while next_offset < end_offset {
18013 _next_ordinal_to_read += 1;
18014 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18015 next_offset += envelope_size;
18016 }
18017
18018 Ok(())
18019 }
18020 }
18021
18022 impl HevcEncoderSettings {
18023 #[inline(always)]
18024 fn max_ordinal_present(&self) -> u64 {
18025 if let Some(_) = self.gop_size {
18026 return 3;
18027 }
18028 if let Some(_) = self.frame_rate {
18029 return 2;
18030 }
18031 if let Some(_) = self.bit_rate {
18032 return 1;
18033 }
18034 0
18035 }
18036 }
18037
18038 impl fidl::encoding::ValueTypeMarker for HevcEncoderSettings {
18039 type Borrowed<'a> = &'a Self;
18040 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18041 value
18042 }
18043 }
18044
18045 unsafe impl fidl::encoding::TypeMarker for HevcEncoderSettings {
18046 type Owned = Self;
18047
18048 #[inline(always)]
18049 fn inline_align(_context: fidl::encoding::Context) -> usize {
18050 8
18051 }
18052
18053 #[inline(always)]
18054 fn inline_size(_context: fidl::encoding::Context) -> usize {
18055 16
18056 }
18057 }
18058
18059 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HevcEncoderSettings, D>
18060 for &HevcEncoderSettings
18061 {
18062 unsafe fn encode(
18063 self,
18064 encoder: &mut fidl::encoding::Encoder<'_, D>,
18065 offset: usize,
18066 mut depth: fidl::encoding::Depth,
18067 ) -> fidl::Result<()> {
18068 encoder.debug_check_bounds::<HevcEncoderSettings>(offset);
18069 let max_ordinal: u64 = self.max_ordinal_present();
18071 encoder.write_num(max_ordinal, offset);
18072 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18073 if max_ordinal == 0 {
18075 return Ok(());
18076 }
18077 depth.increment()?;
18078 let envelope_size = 8;
18079 let bytes_len = max_ordinal as usize * envelope_size;
18080 #[allow(unused_variables)]
18081 let offset = encoder.out_of_line_offset(bytes_len);
18082 let mut _prev_end_offset: usize = 0;
18083 if 1 > max_ordinal {
18084 return Ok(());
18085 }
18086
18087 let cur_offset: usize = (1 - 1) * envelope_size;
18090
18091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18093
18094 fidl::encoding::encode_in_envelope_optional::<u32, D>(
18099 self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18100 encoder,
18101 offset + cur_offset,
18102 depth,
18103 )?;
18104
18105 _prev_end_offset = cur_offset + envelope_size;
18106 if 2 > max_ordinal {
18107 return Ok(());
18108 }
18109
18110 let cur_offset: usize = (2 - 1) * envelope_size;
18113
18114 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18116
18117 fidl::encoding::encode_in_envelope_optional::<u32, D>(
18122 self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18123 encoder,
18124 offset + cur_offset,
18125 depth,
18126 )?;
18127
18128 _prev_end_offset = cur_offset + envelope_size;
18129 if 3 > max_ordinal {
18130 return Ok(());
18131 }
18132
18133 let cur_offset: usize = (3 - 1) * envelope_size;
18136
18137 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18139
18140 fidl::encoding::encode_in_envelope_optional::<u32, D>(
18145 self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18146 encoder,
18147 offset + cur_offset,
18148 depth,
18149 )?;
18150
18151 _prev_end_offset = cur_offset + envelope_size;
18152
18153 Ok(())
18154 }
18155 }
18156
18157 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HevcEncoderSettings {
18158 #[inline(always)]
18159 fn new_empty() -> Self {
18160 Self::default()
18161 }
18162
18163 unsafe fn decode(
18164 &mut self,
18165 decoder: &mut fidl::encoding::Decoder<'_, D>,
18166 offset: usize,
18167 mut depth: fidl::encoding::Depth,
18168 ) -> fidl::Result<()> {
18169 decoder.debug_check_bounds::<Self>(offset);
18170 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18171 None => return Err(fidl::Error::NotNullable),
18172 Some(len) => len,
18173 };
18174 if len == 0 {
18176 return Ok(());
18177 };
18178 depth.increment()?;
18179 let envelope_size = 8;
18180 let bytes_len = len * envelope_size;
18181 let offset = decoder.out_of_line_offset(bytes_len)?;
18182 let mut _next_ordinal_to_read = 0;
18184 let mut next_offset = offset;
18185 let end_offset = offset + bytes_len;
18186 _next_ordinal_to_read += 1;
18187 if next_offset >= end_offset {
18188 return Ok(());
18189 }
18190
18191 while _next_ordinal_to_read < 1 {
18193 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18194 _next_ordinal_to_read += 1;
18195 next_offset += envelope_size;
18196 }
18197
18198 let next_out_of_line = decoder.next_out_of_line();
18199 let handles_before = decoder.remaining_handles();
18200 if let Some((inlined, num_bytes, num_handles)) =
18201 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18202 {
18203 let member_inline_size =
18204 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18205 if inlined != (member_inline_size <= 4) {
18206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18207 }
18208 let inner_offset;
18209 let mut inner_depth = depth.clone();
18210 if inlined {
18211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18212 inner_offset = next_offset;
18213 } else {
18214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18215 inner_depth.increment()?;
18216 }
18217 let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18218 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18220 {
18221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18222 }
18223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18225 }
18226 }
18227
18228 next_offset += envelope_size;
18229 _next_ordinal_to_read += 1;
18230 if next_offset >= end_offset {
18231 return Ok(());
18232 }
18233
18234 while _next_ordinal_to_read < 2 {
18236 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18237 _next_ordinal_to_read += 1;
18238 next_offset += envelope_size;
18239 }
18240
18241 let next_out_of_line = decoder.next_out_of_line();
18242 let handles_before = decoder.remaining_handles();
18243 if let Some((inlined, num_bytes, num_handles)) =
18244 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18245 {
18246 let member_inline_size =
18247 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18248 if inlined != (member_inline_size <= 4) {
18249 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18250 }
18251 let inner_offset;
18252 let mut inner_depth = depth.clone();
18253 if inlined {
18254 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18255 inner_offset = next_offset;
18256 } else {
18257 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18258 inner_depth.increment()?;
18259 }
18260 let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18261 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18262 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18263 {
18264 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18265 }
18266 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18267 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18268 }
18269 }
18270
18271 next_offset += envelope_size;
18272 _next_ordinal_to_read += 1;
18273 if next_offset >= end_offset {
18274 return Ok(());
18275 }
18276
18277 while _next_ordinal_to_read < 3 {
18279 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18280 _next_ordinal_to_read += 1;
18281 next_offset += envelope_size;
18282 }
18283
18284 let next_out_of_line = decoder.next_out_of_line();
18285 let handles_before = decoder.remaining_handles();
18286 if let Some((inlined, num_bytes, num_handles)) =
18287 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18288 {
18289 let member_inline_size =
18290 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18291 if inlined != (member_inline_size <= 4) {
18292 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18293 }
18294 let inner_offset;
18295 let mut inner_depth = depth.clone();
18296 if inlined {
18297 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18298 inner_offset = next_offset;
18299 } else {
18300 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18301 inner_depth.increment()?;
18302 }
18303 let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
18304 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18305 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18306 {
18307 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18308 }
18309 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18310 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18311 }
18312 }
18313
18314 next_offset += envelope_size;
18315
18316 while next_offset < end_offset {
18318 _next_ordinal_to_read += 1;
18319 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18320 next_offset += envelope_size;
18321 }
18322
18323 Ok(())
18324 }
18325 }
18326
18327 impl InputAudioCapturerConfiguration {
18328 #[inline(always)]
18329 fn max_ordinal_present(&self) -> u64 {
18330 if let Some(_) = self.usage2 {
18331 return 2;
18332 }
18333 if let Some(_) = self.usage {
18334 return 1;
18335 }
18336 0
18337 }
18338 }
18339
18340 impl fidl::encoding::ValueTypeMarker for InputAudioCapturerConfiguration {
18341 type Borrowed<'a> = &'a Self;
18342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18343 value
18344 }
18345 }
18346
18347 unsafe impl fidl::encoding::TypeMarker for InputAudioCapturerConfiguration {
18348 type Owned = Self;
18349
18350 #[inline(always)]
18351 fn inline_align(_context: fidl::encoding::Context) -> usize {
18352 8
18353 }
18354
18355 #[inline(always)]
18356 fn inline_size(_context: fidl::encoding::Context) -> usize {
18357 16
18358 }
18359 }
18360
18361 unsafe impl<D: fidl::encoding::ResourceDialect>
18362 fidl::encoding::Encode<InputAudioCapturerConfiguration, D>
18363 for &InputAudioCapturerConfiguration
18364 {
18365 unsafe fn encode(
18366 self,
18367 encoder: &mut fidl::encoding::Encoder<'_, D>,
18368 offset: usize,
18369 mut depth: fidl::encoding::Depth,
18370 ) -> fidl::Result<()> {
18371 encoder.debug_check_bounds::<InputAudioCapturerConfiguration>(offset);
18372 let max_ordinal: u64 = self.max_ordinal_present();
18374 encoder.write_num(max_ordinal, offset);
18375 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18376 if max_ordinal == 0 {
18378 return Ok(());
18379 }
18380 depth.increment()?;
18381 let envelope_size = 8;
18382 let bytes_len = max_ordinal as usize * envelope_size;
18383 #[allow(unused_variables)]
18384 let offset = encoder.out_of_line_offset(bytes_len);
18385 let mut _prev_end_offset: usize = 0;
18386 if 1 > max_ordinal {
18387 return Ok(());
18388 }
18389
18390 let cur_offset: usize = (1 - 1) * envelope_size;
18393
18394 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18396
18397 fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage, D>(
18402 self.usage
18403 .as_ref()
18404 .map(<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow),
18405 encoder,
18406 offset + cur_offset,
18407 depth,
18408 )?;
18409
18410 _prev_end_offset = cur_offset + envelope_size;
18411 if 2 > max_ordinal {
18412 return Ok(());
18413 }
18414
18415 let cur_offset: usize = (2 - 1) * envelope_size;
18418
18419 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18421
18422 fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage2, D>(
18427 self.usage2
18428 .as_ref()
18429 .map(<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow),
18430 encoder,
18431 offset + cur_offset,
18432 depth,
18433 )?;
18434
18435 _prev_end_offset = cur_offset + envelope_size;
18436
18437 Ok(())
18438 }
18439 }
18440
18441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18442 for InputAudioCapturerConfiguration
18443 {
18444 #[inline(always)]
18445 fn new_empty() -> Self {
18446 Self::default()
18447 }
18448
18449 unsafe fn decode(
18450 &mut self,
18451 decoder: &mut fidl::encoding::Decoder<'_, D>,
18452 offset: usize,
18453 mut depth: fidl::encoding::Depth,
18454 ) -> fidl::Result<()> {
18455 decoder.debug_check_bounds::<Self>(offset);
18456 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18457 None => return Err(fidl::Error::NotNullable),
18458 Some(len) => len,
18459 };
18460 if len == 0 {
18462 return Ok(());
18463 };
18464 depth.increment()?;
18465 let envelope_size = 8;
18466 let bytes_len = len * envelope_size;
18467 let offset = decoder.out_of_line_offset(bytes_len)?;
18468 let mut _next_ordinal_to_read = 0;
18470 let mut next_offset = offset;
18471 let end_offset = offset + bytes_len;
18472 _next_ordinal_to_read += 1;
18473 if next_offset >= end_offset {
18474 return Ok(());
18475 }
18476
18477 while _next_ordinal_to_read < 1 {
18479 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18480 _next_ordinal_to_read += 1;
18481 next_offset += envelope_size;
18482 }
18483
18484 let next_out_of_line = decoder.next_out_of_line();
18485 let handles_before = decoder.remaining_handles();
18486 if let Some((inlined, num_bytes, num_handles)) =
18487 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18488 {
18489 let member_inline_size =
18490 <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18491 if inlined != (member_inline_size <= 4) {
18492 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18493 }
18494 let inner_offset;
18495 let mut inner_depth = depth.clone();
18496 if inlined {
18497 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18498 inner_offset = next_offset;
18499 } else {
18500 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18501 inner_depth.increment()?;
18502 }
18503 let val_ref =
18504 self.usage.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage, D));
18505 fidl::decode!(AudioCaptureUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
18506 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18507 {
18508 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18509 }
18510 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18511 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18512 }
18513 }
18514
18515 next_offset += envelope_size;
18516 _next_ordinal_to_read += 1;
18517 if next_offset >= end_offset {
18518 return Ok(());
18519 }
18520
18521 while _next_ordinal_to_read < 2 {
18523 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18524 _next_ordinal_to_read += 1;
18525 next_offset += envelope_size;
18526 }
18527
18528 let next_out_of_line = decoder.next_out_of_line();
18529 let handles_before = decoder.remaining_handles();
18530 if let Some((inlined, num_bytes, num_handles)) =
18531 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18532 {
18533 let member_inline_size =
18534 <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(
18535 decoder.context,
18536 );
18537 if inlined != (member_inline_size <= 4) {
18538 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18539 }
18540 let inner_offset;
18541 let mut inner_depth = depth.clone();
18542 if inlined {
18543 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18544 inner_offset = next_offset;
18545 } else {
18546 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18547 inner_depth.increment()?;
18548 }
18549 let val_ref =
18550 self.usage2.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage2, D));
18551 fidl::decode!(AudioCaptureUsage2, D, val_ref, decoder, inner_offset, inner_depth)?;
18552 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18553 {
18554 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18555 }
18556 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18557 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18558 }
18559 }
18560
18561 next_offset += envelope_size;
18562
18563 while next_offset < end_offset {
18565 _next_ordinal_to_read += 1;
18566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18567 next_offset += envelope_size;
18568 }
18569
18570 Ok(())
18571 }
18572 }
18573
18574 impl Lc3EncoderSettings {
18575 #[inline(always)]
18576 fn max_ordinal_present(&self) -> u64 {
18577 if let Some(_) = self.frame_duration {
18578 return 2;
18579 }
18580 if let Some(_) = self.nbytes {
18581 return 1;
18582 }
18583 0
18584 }
18585 }
18586
18587 impl fidl::encoding::ValueTypeMarker for Lc3EncoderSettings {
18588 type Borrowed<'a> = &'a Self;
18589 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18590 value
18591 }
18592 }
18593
18594 unsafe impl fidl::encoding::TypeMarker for Lc3EncoderSettings {
18595 type Owned = Self;
18596
18597 #[inline(always)]
18598 fn inline_align(_context: fidl::encoding::Context) -> usize {
18599 8
18600 }
18601
18602 #[inline(always)]
18603 fn inline_size(_context: fidl::encoding::Context) -> usize {
18604 16
18605 }
18606 }
18607
18608 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Lc3EncoderSettings, D>
18609 for &Lc3EncoderSettings
18610 {
18611 unsafe fn encode(
18612 self,
18613 encoder: &mut fidl::encoding::Encoder<'_, D>,
18614 offset: usize,
18615 mut depth: fidl::encoding::Depth,
18616 ) -> fidl::Result<()> {
18617 encoder.debug_check_bounds::<Lc3EncoderSettings>(offset);
18618 let max_ordinal: u64 = self.max_ordinal_present();
18620 encoder.write_num(max_ordinal, offset);
18621 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18622 if max_ordinal == 0 {
18624 return Ok(());
18625 }
18626 depth.increment()?;
18627 let envelope_size = 8;
18628 let bytes_len = max_ordinal as usize * envelope_size;
18629 #[allow(unused_variables)]
18630 let offset = encoder.out_of_line_offset(bytes_len);
18631 let mut _prev_end_offset: usize = 0;
18632 if 1 > max_ordinal {
18633 return Ok(());
18634 }
18635
18636 let cur_offset: usize = (1 - 1) * envelope_size;
18639
18640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18642
18643 fidl::encoding::encode_in_envelope_optional::<u16, D>(
18648 self.nbytes.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
18649 encoder,
18650 offset + cur_offset,
18651 depth,
18652 )?;
18653
18654 _prev_end_offset = cur_offset + envelope_size;
18655 if 2 > max_ordinal {
18656 return Ok(());
18657 }
18658
18659 let cur_offset: usize = (2 - 1) * envelope_size;
18662
18663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18665
18666 fidl::encoding::encode_in_envelope_optional::<Lc3FrameDuration, D>(
18671 self.frame_duration
18672 .as_ref()
18673 .map(<Lc3FrameDuration as fidl::encoding::ValueTypeMarker>::borrow),
18674 encoder,
18675 offset + cur_offset,
18676 depth,
18677 )?;
18678
18679 _prev_end_offset = cur_offset + envelope_size;
18680
18681 Ok(())
18682 }
18683 }
18684
18685 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3EncoderSettings {
18686 #[inline(always)]
18687 fn new_empty() -> Self {
18688 Self::default()
18689 }
18690
18691 unsafe fn decode(
18692 &mut self,
18693 decoder: &mut fidl::encoding::Decoder<'_, D>,
18694 offset: usize,
18695 mut depth: fidl::encoding::Depth,
18696 ) -> fidl::Result<()> {
18697 decoder.debug_check_bounds::<Self>(offset);
18698 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18699 None => return Err(fidl::Error::NotNullable),
18700 Some(len) => len,
18701 };
18702 if len == 0 {
18704 return Ok(());
18705 };
18706 depth.increment()?;
18707 let envelope_size = 8;
18708 let bytes_len = len * envelope_size;
18709 let offset = decoder.out_of_line_offset(bytes_len)?;
18710 let mut _next_ordinal_to_read = 0;
18712 let mut next_offset = offset;
18713 let end_offset = offset + bytes_len;
18714 _next_ordinal_to_read += 1;
18715 if next_offset >= end_offset {
18716 return Ok(());
18717 }
18718
18719 while _next_ordinal_to_read < 1 {
18721 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18722 _next_ordinal_to_read += 1;
18723 next_offset += envelope_size;
18724 }
18725
18726 let next_out_of_line = decoder.next_out_of_line();
18727 let handles_before = decoder.remaining_handles();
18728 if let Some((inlined, num_bytes, num_handles)) =
18729 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18730 {
18731 let member_inline_size =
18732 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18733 if inlined != (member_inline_size <= 4) {
18734 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18735 }
18736 let inner_offset;
18737 let mut inner_depth = depth.clone();
18738 if inlined {
18739 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18740 inner_offset = next_offset;
18741 } else {
18742 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18743 inner_depth.increment()?;
18744 }
18745 let val_ref = self.nbytes.get_or_insert_with(|| fidl::new_empty!(u16, D));
18746 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
18747 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18748 {
18749 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18750 }
18751 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18752 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18753 }
18754 }
18755
18756 next_offset += envelope_size;
18757 _next_ordinal_to_read += 1;
18758 if next_offset >= end_offset {
18759 return Ok(());
18760 }
18761
18762 while _next_ordinal_to_read < 2 {
18764 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18765 _next_ordinal_to_read += 1;
18766 next_offset += envelope_size;
18767 }
18768
18769 let next_out_of_line = decoder.next_out_of_line();
18770 let handles_before = decoder.remaining_handles();
18771 if let Some((inlined, num_bytes, num_handles)) =
18772 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18773 {
18774 let member_inline_size =
18775 <Lc3FrameDuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18776 if inlined != (member_inline_size <= 4) {
18777 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18778 }
18779 let inner_offset;
18780 let mut inner_depth = depth.clone();
18781 if inlined {
18782 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18783 inner_offset = next_offset;
18784 } else {
18785 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18786 inner_depth.increment()?;
18787 }
18788 let val_ref = self
18789 .frame_duration
18790 .get_or_insert_with(|| fidl::new_empty!(Lc3FrameDuration, D));
18791 fidl::decode!(Lc3FrameDuration, D, val_ref, decoder, inner_offset, inner_depth)?;
18792 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18793 {
18794 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18795 }
18796 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18797 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18798 }
18799 }
18800
18801 next_offset += envelope_size;
18802
18803 while next_offset < end_offset {
18805 _next_ordinal_to_read += 1;
18806 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18807 next_offset += envelope_size;
18808 }
18809
18810 Ok(())
18811 }
18812 }
18813
18814 impl LoopbackAudioCapturerConfiguration {
18815 #[inline(always)]
18816 fn max_ordinal_present(&self) -> u64 {
18817 0
18818 }
18819 }
18820
18821 impl fidl::encoding::ValueTypeMarker for LoopbackAudioCapturerConfiguration {
18822 type Borrowed<'a> = &'a Self;
18823 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18824 value
18825 }
18826 }
18827
18828 unsafe impl fidl::encoding::TypeMarker for LoopbackAudioCapturerConfiguration {
18829 type Owned = Self;
18830
18831 #[inline(always)]
18832 fn inline_align(_context: fidl::encoding::Context) -> usize {
18833 8
18834 }
18835
18836 #[inline(always)]
18837 fn inline_size(_context: fidl::encoding::Context) -> usize {
18838 16
18839 }
18840 }
18841
18842 unsafe impl<D: fidl::encoding::ResourceDialect>
18843 fidl::encoding::Encode<LoopbackAudioCapturerConfiguration, D>
18844 for &LoopbackAudioCapturerConfiguration
18845 {
18846 unsafe fn encode(
18847 self,
18848 encoder: &mut fidl::encoding::Encoder<'_, D>,
18849 offset: usize,
18850 mut depth: fidl::encoding::Depth,
18851 ) -> fidl::Result<()> {
18852 encoder.debug_check_bounds::<LoopbackAudioCapturerConfiguration>(offset);
18853 let max_ordinal: u64 = self.max_ordinal_present();
18855 encoder.write_num(max_ordinal, offset);
18856 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18857 if max_ordinal == 0 {
18859 return Ok(());
18860 }
18861 depth.increment()?;
18862 let envelope_size = 8;
18863 let bytes_len = max_ordinal as usize * envelope_size;
18864 #[allow(unused_variables)]
18865 let offset = encoder.out_of_line_offset(bytes_len);
18866 let mut _prev_end_offset: usize = 0;
18867
18868 Ok(())
18869 }
18870 }
18871
18872 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18873 for LoopbackAudioCapturerConfiguration
18874 {
18875 #[inline(always)]
18876 fn new_empty() -> Self {
18877 Self::default()
18878 }
18879
18880 unsafe fn decode(
18881 &mut self,
18882 decoder: &mut fidl::encoding::Decoder<'_, D>,
18883 offset: usize,
18884 mut depth: fidl::encoding::Depth,
18885 ) -> fidl::Result<()> {
18886 decoder.debug_check_bounds::<Self>(offset);
18887 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18888 None => return Err(fidl::Error::NotNullable),
18889 Some(len) => len,
18890 };
18891 if len == 0 {
18893 return Ok(());
18894 };
18895 depth.increment()?;
18896 let envelope_size = 8;
18897 let bytes_len = len * envelope_size;
18898 let offset = decoder.out_of_line_offset(bytes_len)?;
18899 let mut _next_ordinal_to_read = 0;
18901 let mut next_offset = offset;
18902 let end_offset = offset + bytes_len;
18903
18904 while next_offset < end_offset {
18906 _next_ordinal_to_read += 1;
18907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18908 next_offset += envelope_size;
18909 }
18910
18911 Ok(())
18912 }
18913 }
18914
18915 impl MSbcEncoderSettings {
18916 #[inline(always)]
18917 fn max_ordinal_present(&self) -> u64 {
18918 0
18919 }
18920 }
18921
18922 impl fidl::encoding::ValueTypeMarker for MSbcEncoderSettings {
18923 type Borrowed<'a> = &'a Self;
18924 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18925 value
18926 }
18927 }
18928
18929 unsafe impl fidl::encoding::TypeMarker for MSbcEncoderSettings {
18930 type Owned = Self;
18931
18932 #[inline(always)]
18933 fn inline_align(_context: fidl::encoding::Context) -> usize {
18934 8
18935 }
18936
18937 #[inline(always)]
18938 fn inline_size(_context: fidl::encoding::Context) -> usize {
18939 16
18940 }
18941 }
18942
18943 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MSbcEncoderSettings, D>
18944 for &MSbcEncoderSettings
18945 {
18946 unsafe fn encode(
18947 self,
18948 encoder: &mut fidl::encoding::Encoder<'_, D>,
18949 offset: usize,
18950 mut depth: fidl::encoding::Depth,
18951 ) -> fidl::Result<()> {
18952 encoder.debug_check_bounds::<MSbcEncoderSettings>(offset);
18953 let max_ordinal: u64 = self.max_ordinal_present();
18955 encoder.write_num(max_ordinal, offset);
18956 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18957 if max_ordinal == 0 {
18959 return Ok(());
18960 }
18961 depth.increment()?;
18962 let envelope_size = 8;
18963 let bytes_len = max_ordinal as usize * envelope_size;
18964 #[allow(unused_variables)]
18965 let offset = encoder.out_of_line_offset(bytes_len);
18966 let mut _prev_end_offset: usize = 0;
18967
18968 Ok(())
18969 }
18970 }
18971
18972 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MSbcEncoderSettings {
18973 #[inline(always)]
18974 fn new_empty() -> Self {
18975 Self::default()
18976 }
18977
18978 unsafe fn decode(
18979 &mut self,
18980 decoder: &mut fidl::encoding::Decoder<'_, D>,
18981 offset: usize,
18982 mut depth: fidl::encoding::Depth,
18983 ) -> fidl::Result<()> {
18984 decoder.debug_check_bounds::<Self>(offset);
18985 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18986 None => return Err(fidl::Error::NotNullable),
18987 Some(len) => len,
18988 };
18989 if len == 0 {
18991 return Ok(());
18992 };
18993 depth.increment()?;
18994 let envelope_size = 8;
18995 let bytes_len = len * envelope_size;
18996 let offset = decoder.out_of_line_offset(bytes_len)?;
18997 let mut _next_ordinal_to_read = 0;
18999 let mut next_offset = offset;
19000 let end_offset = offset + bytes_len;
19001
19002 while next_offset < end_offset {
19004 _next_ordinal_to_read += 1;
19005 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19006 next_offset += envelope_size;
19007 }
19008
19009 Ok(())
19010 }
19011 }
19012
19013 impl Packet {
19014 #[inline(always)]
19015 fn max_ordinal_present(&self) -> u64 {
19016 if let Some(_) = self.key_frame {
19017 return 9;
19018 }
19019 if let Some(_) = self.known_end_access_unit {
19020 return 8;
19021 }
19022 if let Some(_) = self.start_access_unit {
19023 return 7;
19024 }
19025 if let Some(_) = self.timestamp_ish {
19026 return 6;
19027 }
19028 if let Some(_) = self.valid_length_bytes {
19029 return 5;
19030 }
19031 if let Some(_) = self.start_offset {
19032 return 4;
19033 }
19034 if let Some(_) = self.stream_lifetime_ordinal {
19035 return 3;
19036 }
19037 if let Some(_) = self.buffer_index {
19038 return 2;
19039 }
19040 if let Some(_) = self.header {
19041 return 1;
19042 }
19043 0
19044 }
19045 }
19046
19047 impl fidl::encoding::ValueTypeMarker for Packet {
19048 type Borrowed<'a> = &'a Self;
19049 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19050 value
19051 }
19052 }
19053
19054 unsafe impl fidl::encoding::TypeMarker for Packet {
19055 type Owned = Self;
19056
19057 #[inline(always)]
19058 fn inline_align(_context: fidl::encoding::Context) -> usize {
19059 8
19060 }
19061
19062 #[inline(always)]
19063 fn inline_size(_context: fidl::encoding::Context) -> usize {
19064 16
19065 }
19066 }
19067
19068 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Packet, D> for &Packet {
19069 unsafe fn encode(
19070 self,
19071 encoder: &mut fidl::encoding::Encoder<'_, D>,
19072 offset: usize,
19073 mut depth: fidl::encoding::Depth,
19074 ) -> fidl::Result<()> {
19075 encoder.debug_check_bounds::<Packet>(offset);
19076 let max_ordinal: u64 = self.max_ordinal_present();
19078 encoder.write_num(max_ordinal, offset);
19079 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19080 if max_ordinal == 0 {
19082 return Ok(());
19083 }
19084 depth.increment()?;
19085 let envelope_size = 8;
19086 let bytes_len = max_ordinal as usize * envelope_size;
19087 #[allow(unused_variables)]
19088 let offset = encoder.out_of_line_offset(bytes_len);
19089 let mut _prev_end_offset: usize = 0;
19090 if 1 > max_ordinal {
19091 return Ok(());
19092 }
19093
19094 let cur_offset: usize = (1 - 1) * envelope_size;
19097
19098 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19100
19101 fidl::encoding::encode_in_envelope_optional::<PacketHeader, D>(
19106 self.header.as_ref().map(<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow),
19107 encoder,
19108 offset + cur_offset,
19109 depth,
19110 )?;
19111
19112 _prev_end_offset = cur_offset + envelope_size;
19113 if 2 > max_ordinal {
19114 return Ok(());
19115 }
19116
19117 let cur_offset: usize = (2 - 1) * envelope_size;
19120
19121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19123
19124 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19129 self.buffer_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19130 encoder,
19131 offset + cur_offset,
19132 depth,
19133 )?;
19134
19135 _prev_end_offset = cur_offset + envelope_size;
19136 if 3 > max_ordinal {
19137 return Ok(());
19138 }
19139
19140 let cur_offset: usize = (3 - 1) * envelope_size;
19143
19144 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19146
19147 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19152 self.stream_lifetime_ordinal
19153 .as_ref()
19154 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19155 encoder,
19156 offset + cur_offset,
19157 depth,
19158 )?;
19159
19160 _prev_end_offset = cur_offset + envelope_size;
19161 if 4 > max_ordinal {
19162 return Ok(());
19163 }
19164
19165 let cur_offset: usize = (4 - 1) * envelope_size;
19168
19169 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19171
19172 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19177 self.start_offset.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19178 encoder,
19179 offset + cur_offset,
19180 depth,
19181 )?;
19182
19183 _prev_end_offset = cur_offset + envelope_size;
19184 if 5 > max_ordinal {
19185 return Ok(());
19186 }
19187
19188 let cur_offset: usize = (5 - 1) * envelope_size;
19191
19192 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19194
19195 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19200 self.valid_length_bytes
19201 .as_ref()
19202 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19203 encoder,
19204 offset + cur_offset,
19205 depth,
19206 )?;
19207
19208 _prev_end_offset = cur_offset + envelope_size;
19209 if 6 > max_ordinal {
19210 return Ok(());
19211 }
19212
19213 let cur_offset: usize = (6 - 1) * envelope_size;
19216
19217 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19219
19220 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19225 self.timestamp_ish.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19226 encoder,
19227 offset + cur_offset,
19228 depth,
19229 )?;
19230
19231 _prev_end_offset = cur_offset + envelope_size;
19232 if 7 > max_ordinal {
19233 return Ok(());
19234 }
19235
19236 let cur_offset: usize = (7 - 1) * envelope_size;
19239
19240 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19242
19243 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19248 self.start_access_unit
19249 .as_ref()
19250 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19251 encoder,
19252 offset + cur_offset,
19253 depth,
19254 )?;
19255
19256 _prev_end_offset = cur_offset + envelope_size;
19257 if 8 > max_ordinal {
19258 return Ok(());
19259 }
19260
19261 let cur_offset: usize = (8 - 1) * envelope_size;
19264
19265 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19267
19268 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19273 self.known_end_access_unit
19274 .as_ref()
19275 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19276 encoder,
19277 offset + cur_offset,
19278 depth,
19279 )?;
19280
19281 _prev_end_offset = cur_offset + envelope_size;
19282 if 9 > max_ordinal {
19283 return Ok(());
19284 }
19285
19286 let cur_offset: usize = (9 - 1) * envelope_size;
19289
19290 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19292
19293 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19298 self.key_frame.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19299 encoder,
19300 offset + cur_offset,
19301 depth,
19302 )?;
19303
19304 _prev_end_offset = cur_offset + envelope_size;
19305
19306 Ok(())
19307 }
19308 }
19309
19310 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Packet {
19311 #[inline(always)]
19312 fn new_empty() -> Self {
19313 Self::default()
19314 }
19315
19316 unsafe fn decode(
19317 &mut self,
19318 decoder: &mut fidl::encoding::Decoder<'_, D>,
19319 offset: usize,
19320 mut depth: fidl::encoding::Depth,
19321 ) -> fidl::Result<()> {
19322 decoder.debug_check_bounds::<Self>(offset);
19323 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19324 None => return Err(fidl::Error::NotNullable),
19325 Some(len) => len,
19326 };
19327 if len == 0 {
19329 return Ok(());
19330 };
19331 depth.increment()?;
19332 let envelope_size = 8;
19333 let bytes_len = len * envelope_size;
19334 let offset = decoder.out_of_line_offset(bytes_len)?;
19335 let mut _next_ordinal_to_read = 0;
19337 let mut next_offset = offset;
19338 let end_offset = offset + bytes_len;
19339 _next_ordinal_to_read += 1;
19340 if next_offset >= end_offset {
19341 return Ok(());
19342 }
19343
19344 while _next_ordinal_to_read < 1 {
19346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19347 _next_ordinal_to_read += 1;
19348 next_offset += envelope_size;
19349 }
19350
19351 let next_out_of_line = decoder.next_out_of_line();
19352 let handles_before = decoder.remaining_handles();
19353 if let Some((inlined, num_bytes, num_handles)) =
19354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19355 {
19356 let member_inline_size =
19357 <PacketHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19358 if inlined != (member_inline_size <= 4) {
19359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19360 }
19361 let inner_offset;
19362 let mut inner_depth = depth.clone();
19363 if inlined {
19364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19365 inner_offset = next_offset;
19366 } else {
19367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19368 inner_depth.increment()?;
19369 }
19370 let val_ref = self.header.get_or_insert_with(|| fidl::new_empty!(PacketHeader, D));
19371 fidl::decode!(PacketHeader, D, val_ref, decoder, inner_offset, inner_depth)?;
19372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19373 {
19374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19375 }
19376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19378 }
19379 }
19380
19381 next_offset += envelope_size;
19382 _next_ordinal_to_read += 1;
19383 if next_offset >= end_offset {
19384 return Ok(());
19385 }
19386
19387 while _next_ordinal_to_read < 2 {
19389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19390 _next_ordinal_to_read += 1;
19391 next_offset += envelope_size;
19392 }
19393
19394 let next_out_of_line = decoder.next_out_of_line();
19395 let handles_before = decoder.remaining_handles();
19396 if let Some((inlined, num_bytes, num_handles)) =
19397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19398 {
19399 let member_inline_size =
19400 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19401 if inlined != (member_inline_size <= 4) {
19402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19403 }
19404 let inner_offset;
19405 let mut inner_depth = depth.clone();
19406 if inlined {
19407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19408 inner_offset = next_offset;
19409 } else {
19410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19411 inner_depth.increment()?;
19412 }
19413 let val_ref = self.buffer_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19414 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19415 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19416 {
19417 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19418 }
19419 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19420 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19421 }
19422 }
19423
19424 next_offset += envelope_size;
19425 _next_ordinal_to_read += 1;
19426 if next_offset >= end_offset {
19427 return Ok(());
19428 }
19429
19430 while _next_ordinal_to_read < 3 {
19432 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19433 _next_ordinal_to_read += 1;
19434 next_offset += envelope_size;
19435 }
19436
19437 let next_out_of_line = decoder.next_out_of_line();
19438 let handles_before = decoder.remaining_handles();
19439 if let Some((inlined, num_bytes, num_handles)) =
19440 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19441 {
19442 let member_inline_size =
19443 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19444 if inlined != (member_inline_size <= 4) {
19445 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19446 }
19447 let inner_offset;
19448 let mut inner_depth = depth.clone();
19449 if inlined {
19450 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19451 inner_offset = next_offset;
19452 } else {
19453 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19454 inner_depth.increment()?;
19455 }
19456 let val_ref =
19457 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19458 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19459 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19460 {
19461 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19462 }
19463 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19464 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19465 }
19466 }
19467
19468 next_offset += envelope_size;
19469 _next_ordinal_to_read += 1;
19470 if next_offset >= end_offset {
19471 return Ok(());
19472 }
19473
19474 while _next_ordinal_to_read < 4 {
19476 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19477 _next_ordinal_to_read += 1;
19478 next_offset += envelope_size;
19479 }
19480
19481 let next_out_of_line = decoder.next_out_of_line();
19482 let handles_before = decoder.remaining_handles();
19483 if let Some((inlined, num_bytes, num_handles)) =
19484 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19485 {
19486 let member_inline_size =
19487 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19488 if inlined != (member_inline_size <= 4) {
19489 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19490 }
19491 let inner_offset;
19492 let mut inner_depth = depth.clone();
19493 if inlined {
19494 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19495 inner_offset = next_offset;
19496 } else {
19497 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19498 inner_depth.increment()?;
19499 }
19500 let val_ref = self.start_offset.get_or_insert_with(|| fidl::new_empty!(u32, D));
19501 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19502 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19503 {
19504 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19505 }
19506 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19507 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19508 }
19509 }
19510
19511 next_offset += envelope_size;
19512 _next_ordinal_to_read += 1;
19513 if next_offset >= end_offset {
19514 return Ok(());
19515 }
19516
19517 while _next_ordinal_to_read < 5 {
19519 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19520 _next_ordinal_to_read += 1;
19521 next_offset += envelope_size;
19522 }
19523
19524 let next_out_of_line = decoder.next_out_of_line();
19525 let handles_before = decoder.remaining_handles();
19526 if let Some((inlined, num_bytes, num_handles)) =
19527 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19528 {
19529 let member_inline_size =
19530 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19531 if inlined != (member_inline_size <= 4) {
19532 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19533 }
19534 let inner_offset;
19535 let mut inner_depth = depth.clone();
19536 if inlined {
19537 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19538 inner_offset = next_offset;
19539 } else {
19540 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19541 inner_depth.increment()?;
19542 }
19543 let val_ref =
19544 self.valid_length_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
19545 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19546 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19547 {
19548 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19549 }
19550 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19551 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19552 }
19553 }
19554
19555 next_offset += envelope_size;
19556 _next_ordinal_to_read += 1;
19557 if next_offset >= end_offset {
19558 return Ok(());
19559 }
19560
19561 while _next_ordinal_to_read < 6 {
19563 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19564 _next_ordinal_to_read += 1;
19565 next_offset += envelope_size;
19566 }
19567
19568 let next_out_of_line = decoder.next_out_of_line();
19569 let handles_before = decoder.remaining_handles();
19570 if let Some((inlined, num_bytes, num_handles)) =
19571 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19572 {
19573 let member_inline_size =
19574 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19575 if inlined != (member_inline_size <= 4) {
19576 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19577 }
19578 let inner_offset;
19579 let mut inner_depth = depth.clone();
19580 if inlined {
19581 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19582 inner_offset = next_offset;
19583 } else {
19584 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19585 inner_depth.increment()?;
19586 }
19587 let val_ref = self.timestamp_ish.get_or_insert_with(|| fidl::new_empty!(u64, D));
19588 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19589 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19590 {
19591 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19592 }
19593 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19594 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19595 }
19596 }
19597
19598 next_offset += envelope_size;
19599 _next_ordinal_to_read += 1;
19600 if next_offset >= end_offset {
19601 return Ok(());
19602 }
19603
19604 while _next_ordinal_to_read < 7 {
19606 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19607 _next_ordinal_to_read += 1;
19608 next_offset += envelope_size;
19609 }
19610
19611 let next_out_of_line = decoder.next_out_of_line();
19612 let handles_before = decoder.remaining_handles();
19613 if let Some((inlined, num_bytes, num_handles)) =
19614 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19615 {
19616 let member_inline_size =
19617 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19618 if inlined != (member_inline_size <= 4) {
19619 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19620 }
19621 let inner_offset;
19622 let mut inner_depth = depth.clone();
19623 if inlined {
19624 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19625 inner_offset = next_offset;
19626 } else {
19627 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19628 inner_depth.increment()?;
19629 }
19630 let val_ref =
19631 self.start_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19632 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19633 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19634 {
19635 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19636 }
19637 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19638 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19639 }
19640 }
19641
19642 next_offset += envelope_size;
19643 _next_ordinal_to_read += 1;
19644 if next_offset >= end_offset {
19645 return Ok(());
19646 }
19647
19648 while _next_ordinal_to_read < 8 {
19650 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19651 _next_ordinal_to_read += 1;
19652 next_offset += envelope_size;
19653 }
19654
19655 let next_out_of_line = decoder.next_out_of_line();
19656 let handles_before = decoder.remaining_handles();
19657 if let Some((inlined, num_bytes, num_handles)) =
19658 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19659 {
19660 let member_inline_size =
19661 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19662 if inlined != (member_inline_size <= 4) {
19663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19664 }
19665 let inner_offset;
19666 let mut inner_depth = depth.clone();
19667 if inlined {
19668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19669 inner_offset = next_offset;
19670 } else {
19671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19672 inner_depth.increment()?;
19673 }
19674 let val_ref =
19675 self.known_end_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19676 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19677 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19678 {
19679 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19680 }
19681 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19682 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19683 }
19684 }
19685
19686 next_offset += envelope_size;
19687 _next_ordinal_to_read += 1;
19688 if next_offset >= end_offset {
19689 return Ok(());
19690 }
19691
19692 while _next_ordinal_to_read < 9 {
19694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19695 _next_ordinal_to_read += 1;
19696 next_offset += envelope_size;
19697 }
19698
19699 let next_out_of_line = decoder.next_out_of_line();
19700 let handles_before = decoder.remaining_handles();
19701 if let Some((inlined, num_bytes, num_handles)) =
19702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19703 {
19704 let member_inline_size =
19705 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19706 if inlined != (member_inline_size <= 4) {
19707 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19708 }
19709 let inner_offset;
19710 let mut inner_depth = depth.clone();
19711 if inlined {
19712 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19713 inner_offset = next_offset;
19714 } else {
19715 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19716 inner_depth.increment()?;
19717 }
19718 let val_ref = self.key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
19719 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19720 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19721 {
19722 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19723 }
19724 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19725 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19726 }
19727 }
19728
19729 next_offset += envelope_size;
19730
19731 while next_offset < end_offset {
19733 _next_ordinal_to_read += 1;
19734 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19735 next_offset += envelope_size;
19736 }
19737
19738 Ok(())
19739 }
19740 }
19741
19742 impl PacketHeader {
19743 #[inline(always)]
19744 fn max_ordinal_present(&self) -> u64 {
19745 if let Some(_) = self.packet_index {
19746 return 2;
19747 }
19748 if let Some(_) = self.buffer_lifetime_ordinal {
19749 return 1;
19750 }
19751 0
19752 }
19753 }
19754
19755 impl fidl::encoding::ValueTypeMarker for PacketHeader {
19756 type Borrowed<'a> = &'a Self;
19757 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19758 value
19759 }
19760 }
19761
19762 unsafe impl fidl::encoding::TypeMarker for PacketHeader {
19763 type Owned = Self;
19764
19765 #[inline(always)]
19766 fn inline_align(_context: fidl::encoding::Context) -> usize {
19767 8
19768 }
19769
19770 #[inline(always)]
19771 fn inline_size(_context: fidl::encoding::Context) -> usize {
19772 16
19773 }
19774 }
19775
19776 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PacketHeader, D>
19777 for &PacketHeader
19778 {
19779 unsafe fn encode(
19780 self,
19781 encoder: &mut fidl::encoding::Encoder<'_, D>,
19782 offset: usize,
19783 mut depth: fidl::encoding::Depth,
19784 ) -> fidl::Result<()> {
19785 encoder.debug_check_bounds::<PacketHeader>(offset);
19786 let max_ordinal: u64 = self.max_ordinal_present();
19788 encoder.write_num(max_ordinal, offset);
19789 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19790 if max_ordinal == 0 {
19792 return Ok(());
19793 }
19794 depth.increment()?;
19795 let envelope_size = 8;
19796 let bytes_len = max_ordinal as usize * envelope_size;
19797 #[allow(unused_variables)]
19798 let offset = encoder.out_of_line_offset(bytes_len);
19799 let mut _prev_end_offset: usize = 0;
19800 if 1 > max_ordinal {
19801 return Ok(());
19802 }
19803
19804 let cur_offset: usize = (1 - 1) * envelope_size;
19807
19808 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19810
19811 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19816 self.buffer_lifetime_ordinal
19817 .as_ref()
19818 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19819 encoder,
19820 offset + cur_offset,
19821 depth,
19822 )?;
19823
19824 _prev_end_offset = cur_offset + envelope_size;
19825 if 2 > max_ordinal {
19826 return Ok(());
19827 }
19828
19829 let cur_offset: usize = (2 - 1) * envelope_size;
19832
19833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19835
19836 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19841 self.packet_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19842 encoder,
19843 offset + cur_offset,
19844 depth,
19845 )?;
19846
19847 _prev_end_offset = cur_offset + envelope_size;
19848
19849 Ok(())
19850 }
19851 }
19852
19853 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PacketHeader {
19854 #[inline(always)]
19855 fn new_empty() -> Self {
19856 Self::default()
19857 }
19858
19859 unsafe fn decode(
19860 &mut self,
19861 decoder: &mut fidl::encoding::Decoder<'_, D>,
19862 offset: usize,
19863 mut depth: fidl::encoding::Depth,
19864 ) -> fidl::Result<()> {
19865 decoder.debug_check_bounds::<Self>(offset);
19866 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19867 None => return Err(fidl::Error::NotNullable),
19868 Some(len) => len,
19869 };
19870 if len == 0 {
19872 return Ok(());
19873 };
19874 depth.increment()?;
19875 let envelope_size = 8;
19876 let bytes_len = len * envelope_size;
19877 let offset = decoder.out_of_line_offset(bytes_len)?;
19878 let mut _next_ordinal_to_read = 0;
19880 let mut next_offset = offset;
19881 let end_offset = offset + bytes_len;
19882 _next_ordinal_to_read += 1;
19883 if next_offset >= end_offset {
19884 return Ok(());
19885 }
19886
19887 while _next_ordinal_to_read < 1 {
19889 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19890 _next_ordinal_to_read += 1;
19891 next_offset += envelope_size;
19892 }
19893
19894 let next_out_of_line = decoder.next_out_of_line();
19895 let handles_before = decoder.remaining_handles();
19896 if let Some((inlined, num_bytes, num_handles)) =
19897 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19898 {
19899 let member_inline_size =
19900 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19901 if inlined != (member_inline_size <= 4) {
19902 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19903 }
19904 let inner_offset;
19905 let mut inner_depth = depth.clone();
19906 if inlined {
19907 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19908 inner_offset = next_offset;
19909 } else {
19910 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19911 inner_depth.increment()?;
19912 }
19913 let val_ref =
19914 self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19915 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19916 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19917 {
19918 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19919 }
19920 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19921 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19922 }
19923 }
19924
19925 next_offset += envelope_size;
19926 _next_ordinal_to_read += 1;
19927 if next_offset >= end_offset {
19928 return Ok(());
19929 }
19930
19931 while _next_ordinal_to_read < 2 {
19933 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19934 _next_ordinal_to_read += 1;
19935 next_offset += envelope_size;
19936 }
19937
19938 let next_out_of_line = decoder.next_out_of_line();
19939 let handles_before = decoder.remaining_handles();
19940 if let Some((inlined, num_bytes, num_handles)) =
19941 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19942 {
19943 let member_inline_size =
19944 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19945 if inlined != (member_inline_size <= 4) {
19946 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19947 }
19948 let inner_offset;
19949 let mut inner_depth = depth.clone();
19950 if inlined {
19951 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19952 inner_offset = next_offset;
19953 } else {
19954 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19955 inner_depth.increment()?;
19956 }
19957 let val_ref = self.packet_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19958 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19959 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19960 {
19961 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19962 }
19963 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19964 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19965 }
19966 }
19967
19968 next_offset += envelope_size;
19969
19970 while next_offset < end_offset {
19972 _next_ordinal_to_read += 1;
19973 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19974 next_offset += envelope_size;
19975 }
19976
19977 Ok(())
19978 }
19979 }
19980
19981 impl StreamBufferConstraints {
19982 #[inline(always)]
19983 fn max_ordinal_present(&self) -> u64 {
19984 if let Some(_) = self.is_physically_contiguous_required {
19985 return 13;
19986 }
19987 if let Some(_) = self.single_buffer_mode_allowed {
19988 return 12;
19989 }
19990 if let Some(_) = self.packet_count_for_client_max {
19991 return 11;
19992 }
19993 if let Some(_) = self.packet_count_for_client_min {
19994 return 10;
19995 }
19996 if let Some(_) = self.packet_count_for_server_max {
19997 return 9;
19998 }
19999 if let Some(_) = self.packet_count_for_server_recommended_max {
20000 return 8;
20001 }
20002 if let Some(_) = self.packet_count_for_server_recommended {
20003 return 7;
20004 }
20005 if let Some(_) = self.packet_count_for_server_min {
20006 return 6;
20007 }
20008 if let Some(_) = self.per_packet_buffer_bytes_max {
20009 return 5;
20010 }
20011 if let Some(_) = self.per_packet_buffer_bytes_recommended {
20012 return 4;
20013 }
20014 if let Some(_) = self.per_packet_buffer_bytes_min {
20015 return 3;
20016 }
20017 if let Some(_) = self.default_settings {
20018 return 2;
20019 }
20020 if let Some(_) = self.buffer_constraints_version_ordinal {
20021 return 1;
20022 }
20023 0
20024 }
20025 }
20026
20027 impl fidl::encoding::ValueTypeMarker for StreamBufferConstraints {
20028 type Borrowed<'a> = &'a Self;
20029 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20030 value
20031 }
20032 }
20033
20034 unsafe impl fidl::encoding::TypeMarker for StreamBufferConstraints {
20035 type Owned = Self;
20036
20037 #[inline(always)]
20038 fn inline_align(_context: fidl::encoding::Context) -> usize {
20039 8
20040 }
20041
20042 #[inline(always)]
20043 fn inline_size(_context: fidl::encoding::Context) -> usize {
20044 16
20045 }
20046 }
20047
20048 unsafe impl<D: fidl::encoding::ResourceDialect>
20049 fidl::encoding::Encode<StreamBufferConstraints, D> for &StreamBufferConstraints
20050 {
20051 unsafe fn encode(
20052 self,
20053 encoder: &mut fidl::encoding::Encoder<'_, D>,
20054 offset: usize,
20055 mut depth: fidl::encoding::Depth,
20056 ) -> fidl::Result<()> {
20057 encoder.debug_check_bounds::<StreamBufferConstraints>(offset);
20058 let max_ordinal: u64 = self.max_ordinal_present();
20060 encoder.write_num(max_ordinal, offset);
20061 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20062 if max_ordinal == 0 {
20064 return Ok(());
20065 }
20066 depth.increment()?;
20067 let envelope_size = 8;
20068 let bytes_len = max_ordinal as usize * envelope_size;
20069 #[allow(unused_variables)]
20070 let offset = encoder.out_of_line_offset(bytes_len);
20071 let mut _prev_end_offset: usize = 0;
20072 if 1 > max_ordinal {
20073 return Ok(());
20074 }
20075
20076 let cur_offset: usize = (1 - 1) * envelope_size;
20079
20080 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20082
20083 fidl::encoding::encode_in_envelope_optional::<u64, D>(
20088 self.buffer_constraints_version_ordinal
20089 .as_ref()
20090 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
20091 encoder,
20092 offset + cur_offset,
20093 depth,
20094 )?;
20095
20096 _prev_end_offset = cur_offset + envelope_size;
20097 if 2 > max_ordinal {
20098 return Ok(());
20099 }
20100
20101 let cur_offset: usize = (2 - 1) * envelope_size;
20104
20105 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20107
20108 fidl::encoding::encode_in_envelope_optional::<StreamBufferSettings, D>(
20113 self.default_settings
20114 .as_ref()
20115 .map(<StreamBufferSettings as fidl::encoding::ValueTypeMarker>::borrow),
20116 encoder,
20117 offset + cur_offset,
20118 depth,
20119 )?;
20120
20121 _prev_end_offset = cur_offset + envelope_size;
20122 if 3 > max_ordinal {
20123 return Ok(());
20124 }
20125
20126 let cur_offset: usize = (3 - 1) * envelope_size;
20129
20130 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20132
20133 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20138 self.per_packet_buffer_bytes_min
20139 .as_ref()
20140 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20141 encoder,
20142 offset + cur_offset,
20143 depth,
20144 )?;
20145
20146 _prev_end_offset = cur_offset + envelope_size;
20147 if 4 > max_ordinal {
20148 return Ok(());
20149 }
20150
20151 let cur_offset: usize = (4 - 1) * envelope_size;
20154
20155 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20157
20158 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20163 self.per_packet_buffer_bytes_recommended
20164 .as_ref()
20165 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20166 encoder,
20167 offset + cur_offset,
20168 depth,
20169 )?;
20170
20171 _prev_end_offset = cur_offset + envelope_size;
20172 if 5 > max_ordinal {
20173 return Ok(());
20174 }
20175
20176 let cur_offset: usize = (5 - 1) * envelope_size;
20179
20180 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20182
20183 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20188 self.per_packet_buffer_bytes_max
20189 .as_ref()
20190 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20191 encoder,
20192 offset + cur_offset,
20193 depth,
20194 )?;
20195
20196 _prev_end_offset = cur_offset + envelope_size;
20197 if 6 > max_ordinal {
20198 return Ok(());
20199 }
20200
20201 let cur_offset: usize = (6 - 1) * envelope_size;
20204
20205 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20207
20208 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20213 self.packet_count_for_server_min
20214 .as_ref()
20215 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20216 encoder,
20217 offset + cur_offset,
20218 depth,
20219 )?;
20220
20221 _prev_end_offset = cur_offset + envelope_size;
20222 if 7 > max_ordinal {
20223 return Ok(());
20224 }
20225
20226 let cur_offset: usize = (7 - 1) * envelope_size;
20229
20230 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20232
20233 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20238 self.packet_count_for_server_recommended
20239 .as_ref()
20240 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20241 encoder,
20242 offset + cur_offset,
20243 depth,
20244 )?;
20245
20246 _prev_end_offset = cur_offset + envelope_size;
20247 if 8 > max_ordinal {
20248 return Ok(());
20249 }
20250
20251 let cur_offset: usize = (8 - 1) * envelope_size;
20254
20255 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20257
20258 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20263 self.packet_count_for_server_recommended_max
20264 .as_ref()
20265 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20266 encoder,
20267 offset + cur_offset,
20268 depth,
20269 )?;
20270
20271 _prev_end_offset = cur_offset + envelope_size;
20272 if 9 > max_ordinal {
20273 return Ok(());
20274 }
20275
20276 let cur_offset: usize = (9 - 1) * envelope_size;
20279
20280 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20282
20283 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20288 self.packet_count_for_server_max
20289 .as_ref()
20290 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20291 encoder,
20292 offset + cur_offset,
20293 depth,
20294 )?;
20295
20296 _prev_end_offset = cur_offset + envelope_size;
20297 if 10 > max_ordinal {
20298 return Ok(());
20299 }
20300
20301 let cur_offset: usize = (10 - 1) * envelope_size;
20304
20305 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20307
20308 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20313 self.packet_count_for_client_min
20314 .as_ref()
20315 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20316 encoder,
20317 offset + cur_offset,
20318 depth,
20319 )?;
20320
20321 _prev_end_offset = cur_offset + envelope_size;
20322 if 11 > max_ordinal {
20323 return Ok(());
20324 }
20325
20326 let cur_offset: usize = (11 - 1) * envelope_size;
20329
20330 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20332
20333 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20338 self.packet_count_for_client_max
20339 .as_ref()
20340 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20341 encoder,
20342 offset + cur_offset,
20343 depth,
20344 )?;
20345
20346 _prev_end_offset = cur_offset + envelope_size;
20347 if 12 > max_ordinal {
20348 return Ok(());
20349 }
20350
20351 let cur_offset: usize = (12 - 1) * envelope_size;
20354
20355 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20357
20358 fidl::encoding::encode_in_envelope_optional::<bool, D>(
20363 self.single_buffer_mode_allowed
20364 .as_ref()
20365 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20366 encoder,
20367 offset + cur_offset,
20368 depth,
20369 )?;
20370
20371 _prev_end_offset = cur_offset + envelope_size;
20372 if 13 > max_ordinal {
20373 return Ok(());
20374 }
20375
20376 let cur_offset: usize = (13 - 1) * envelope_size;
20379
20380 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20382
20383 fidl::encoding::encode_in_envelope_optional::<bool, D>(
20388 self.is_physically_contiguous_required
20389 .as_ref()
20390 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20391 encoder,
20392 offset + cur_offset,
20393 depth,
20394 )?;
20395
20396 _prev_end_offset = cur_offset + envelope_size;
20397
20398 Ok(())
20399 }
20400 }
20401
20402 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
20403 for StreamBufferConstraints
20404 {
20405 #[inline(always)]
20406 fn new_empty() -> Self {
20407 Self::default()
20408 }
20409
20410 unsafe fn decode(
20411 &mut self,
20412 decoder: &mut fidl::encoding::Decoder<'_, D>,
20413 offset: usize,
20414 mut depth: fidl::encoding::Depth,
20415 ) -> fidl::Result<()> {
20416 decoder.debug_check_bounds::<Self>(offset);
20417 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20418 None => return Err(fidl::Error::NotNullable),
20419 Some(len) => len,
20420 };
20421 if len == 0 {
20423 return Ok(());
20424 };
20425 depth.increment()?;
20426 let envelope_size = 8;
20427 let bytes_len = len * envelope_size;
20428 let offset = decoder.out_of_line_offset(bytes_len)?;
20429 let mut _next_ordinal_to_read = 0;
20431 let mut next_offset = offset;
20432 let end_offset = offset + bytes_len;
20433 _next_ordinal_to_read += 1;
20434 if next_offset >= end_offset {
20435 return Ok(());
20436 }
20437
20438 while _next_ordinal_to_read < 1 {
20440 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20441 _next_ordinal_to_read += 1;
20442 next_offset += envelope_size;
20443 }
20444
20445 let next_out_of_line = decoder.next_out_of_line();
20446 let handles_before = decoder.remaining_handles();
20447 if let Some((inlined, num_bytes, num_handles)) =
20448 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20449 {
20450 let member_inline_size =
20451 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20452 if inlined != (member_inline_size <= 4) {
20453 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20454 }
20455 let inner_offset;
20456 let mut inner_depth = depth.clone();
20457 if inlined {
20458 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20459 inner_offset = next_offset;
20460 } else {
20461 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20462 inner_depth.increment()?;
20463 }
20464 let val_ref = self
20465 .buffer_constraints_version_ordinal
20466 .get_or_insert_with(|| fidl::new_empty!(u64, D));
20467 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
20468 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20469 {
20470 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20471 }
20472 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20473 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20474 }
20475 }
20476
20477 next_offset += envelope_size;
20478 _next_ordinal_to_read += 1;
20479 if next_offset >= end_offset {
20480 return Ok(());
20481 }
20482
20483 while _next_ordinal_to_read < 2 {
20485 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20486 _next_ordinal_to_read += 1;
20487 next_offset += envelope_size;
20488 }
20489
20490 let next_out_of_line = decoder.next_out_of_line();
20491 let handles_before = decoder.remaining_handles();
20492 if let Some((inlined, num_bytes, num_handles)) =
20493 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20494 {
20495 let member_inline_size =
20496 <StreamBufferSettings as fidl::encoding::TypeMarker>::inline_size(
20497 decoder.context,
20498 );
20499 if inlined != (member_inline_size <= 4) {
20500 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20501 }
20502 let inner_offset;
20503 let mut inner_depth = depth.clone();
20504 if inlined {
20505 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20506 inner_offset = next_offset;
20507 } else {
20508 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20509 inner_depth.increment()?;
20510 }
20511 let val_ref = self
20512 .default_settings
20513 .get_or_insert_with(|| fidl::new_empty!(StreamBufferSettings, D));
20514 fidl::decode!(
20515 StreamBufferSettings,
20516 D,
20517 val_ref,
20518 decoder,
20519 inner_offset,
20520 inner_depth
20521 )?;
20522 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20523 {
20524 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20525 }
20526 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20527 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20528 }
20529 }
20530
20531 next_offset += envelope_size;
20532 _next_ordinal_to_read += 1;
20533 if next_offset >= end_offset {
20534 return Ok(());
20535 }
20536
20537 while _next_ordinal_to_read < 3 {
20539 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20540 _next_ordinal_to_read += 1;
20541 next_offset += envelope_size;
20542 }
20543
20544 let next_out_of_line = decoder.next_out_of_line();
20545 let handles_before = decoder.remaining_handles();
20546 if let Some((inlined, num_bytes, num_handles)) =
20547 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20548 {
20549 let member_inline_size =
20550 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20551 if inlined != (member_inline_size <= 4) {
20552 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20553 }
20554 let inner_offset;
20555 let mut inner_depth = depth.clone();
20556 if inlined {
20557 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20558 inner_offset = next_offset;
20559 } else {
20560 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20561 inner_depth.increment()?;
20562 }
20563 let val_ref = self
20564 .per_packet_buffer_bytes_min
20565 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20566 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20567 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20568 {
20569 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20570 }
20571 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20572 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20573 }
20574 }
20575
20576 next_offset += envelope_size;
20577 _next_ordinal_to_read += 1;
20578 if next_offset >= end_offset {
20579 return Ok(());
20580 }
20581
20582 while _next_ordinal_to_read < 4 {
20584 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20585 _next_ordinal_to_read += 1;
20586 next_offset += envelope_size;
20587 }
20588
20589 let next_out_of_line = decoder.next_out_of_line();
20590 let handles_before = decoder.remaining_handles();
20591 if let Some((inlined, num_bytes, num_handles)) =
20592 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20593 {
20594 let member_inline_size =
20595 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20596 if inlined != (member_inline_size <= 4) {
20597 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20598 }
20599 let inner_offset;
20600 let mut inner_depth = depth.clone();
20601 if inlined {
20602 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20603 inner_offset = next_offset;
20604 } else {
20605 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20606 inner_depth.increment()?;
20607 }
20608 let val_ref = self
20609 .per_packet_buffer_bytes_recommended
20610 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20611 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20612 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20613 {
20614 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20615 }
20616 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20617 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20618 }
20619 }
20620
20621 next_offset += envelope_size;
20622 _next_ordinal_to_read += 1;
20623 if next_offset >= end_offset {
20624 return Ok(());
20625 }
20626
20627 while _next_ordinal_to_read < 5 {
20629 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20630 _next_ordinal_to_read += 1;
20631 next_offset += envelope_size;
20632 }
20633
20634 let next_out_of_line = decoder.next_out_of_line();
20635 let handles_before = decoder.remaining_handles();
20636 if let Some((inlined, num_bytes, num_handles)) =
20637 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20638 {
20639 let member_inline_size =
20640 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20641 if inlined != (member_inline_size <= 4) {
20642 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20643 }
20644 let inner_offset;
20645 let mut inner_depth = depth.clone();
20646 if inlined {
20647 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20648 inner_offset = next_offset;
20649 } else {
20650 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20651 inner_depth.increment()?;
20652 }
20653 let val_ref = self
20654 .per_packet_buffer_bytes_max
20655 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20656 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20657 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20658 {
20659 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20660 }
20661 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20662 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20663 }
20664 }
20665
20666 next_offset += envelope_size;
20667 _next_ordinal_to_read += 1;
20668 if next_offset >= end_offset {
20669 return Ok(());
20670 }
20671
20672 while _next_ordinal_to_read < 6 {
20674 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20675 _next_ordinal_to_read += 1;
20676 next_offset += envelope_size;
20677 }
20678
20679 let next_out_of_line = decoder.next_out_of_line();
20680 let handles_before = decoder.remaining_handles();
20681 if let Some((inlined, num_bytes, num_handles)) =
20682 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20683 {
20684 let member_inline_size =
20685 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20686 if inlined != (member_inline_size <= 4) {
20687 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20688 }
20689 let inner_offset;
20690 let mut inner_depth = depth.clone();
20691 if inlined {
20692 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20693 inner_offset = next_offset;
20694 } else {
20695 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20696 inner_depth.increment()?;
20697 }
20698 let val_ref = self
20699 .packet_count_for_server_min
20700 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20701 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20702 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20703 {
20704 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20705 }
20706 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20707 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20708 }
20709 }
20710
20711 next_offset += envelope_size;
20712 _next_ordinal_to_read += 1;
20713 if next_offset >= end_offset {
20714 return Ok(());
20715 }
20716
20717 while _next_ordinal_to_read < 7 {
20719 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20720 _next_ordinal_to_read += 1;
20721 next_offset += envelope_size;
20722 }
20723
20724 let next_out_of_line = decoder.next_out_of_line();
20725 let handles_before = decoder.remaining_handles();
20726 if let Some((inlined, num_bytes, num_handles)) =
20727 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20728 {
20729 let member_inline_size =
20730 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20731 if inlined != (member_inline_size <= 4) {
20732 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20733 }
20734 let inner_offset;
20735 let mut inner_depth = depth.clone();
20736 if inlined {
20737 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20738 inner_offset = next_offset;
20739 } else {
20740 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20741 inner_depth.increment()?;
20742 }
20743 let val_ref = self
20744 .packet_count_for_server_recommended
20745 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20746 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20747 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20748 {
20749 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20750 }
20751 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20752 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20753 }
20754 }
20755
20756 next_offset += envelope_size;
20757 _next_ordinal_to_read += 1;
20758 if next_offset >= end_offset {
20759 return Ok(());
20760 }
20761
20762 while _next_ordinal_to_read < 8 {
20764 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20765 _next_ordinal_to_read += 1;
20766 next_offset += envelope_size;
20767 }
20768
20769 let next_out_of_line = decoder.next_out_of_line();
20770 let handles_before = decoder.remaining_handles();
20771 if let Some((inlined, num_bytes, num_handles)) =
20772 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20773 {
20774 let member_inline_size =
20775 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20776 if inlined != (member_inline_size <= 4) {
20777 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20778 }
20779 let inner_offset;
20780 let mut inner_depth = depth.clone();
20781 if inlined {
20782 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20783 inner_offset = next_offset;
20784 } else {
20785 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20786 inner_depth.increment()?;
20787 }
20788 let val_ref = self
20789 .packet_count_for_server_recommended_max
20790 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20791 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20792 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20793 {
20794 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20795 }
20796 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20797 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20798 }
20799 }
20800
20801 next_offset += envelope_size;
20802 _next_ordinal_to_read += 1;
20803 if next_offset >= end_offset {
20804 return Ok(());
20805 }
20806
20807 while _next_ordinal_to_read < 9 {
20809 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20810 _next_ordinal_to_read += 1;
20811 next_offset += envelope_size;
20812 }
20813
20814 let next_out_of_line = decoder.next_out_of_line();
20815 let handles_before = decoder.remaining_handles();
20816 if let Some((inlined, num_bytes, num_handles)) =
20817 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20818 {
20819 let member_inline_size =
20820 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20821 if inlined != (member_inline_size <= 4) {
20822 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20823 }
20824 let inner_offset;
20825 let mut inner_depth = depth.clone();
20826 if inlined {
20827 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20828 inner_offset = next_offset;
20829 } else {
20830 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20831 inner_depth.increment()?;
20832 }
20833 let val_ref = self
20834 .packet_count_for_server_max
20835 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20836 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20837 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20838 {
20839 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20840 }
20841 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20842 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20843 }
20844 }
20845
20846 next_offset += envelope_size;
20847 _next_ordinal_to_read += 1;
20848 if next_offset >= end_offset {
20849 return Ok(());
20850 }
20851
20852 while _next_ordinal_to_read < 10 {
20854 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20855 _next_ordinal_to_read += 1;
20856 next_offset += envelope_size;
20857 }
20858
20859 let next_out_of_line = decoder.next_out_of_line();
20860 let handles_before = decoder.remaining_handles();
20861 if let Some((inlined, num_bytes, num_handles)) =
20862 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20863 {
20864 let member_inline_size =
20865 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20866 if inlined != (member_inline_size <= 4) {
20867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20868 }
20869 let inner_offset;
20870 let mut inner_depth = depth.clone();
20871 if inlined {
20872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20873 inner_offset = next_offset;
20874 } else {
20875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20876 inner_depth.increment()?;
20877 }
20878 let val_ref = self
20879 .packet_count_for_client_min
20880 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20881 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20882 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20883 {
20884 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20885 }
20886 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20887 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20888 }
20889 }
20890
20891 next_offset += envelope_size;
20892 _next_ordinal_to_read += 1;
20893 if next_offset >= end_offset {
20894 return Ok(());
20895 }
20896
20897 while _next_ordinal_to_read < 11 {
20899 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20900 _next_ordinal_to_read += 1;
20901 next_offset += envelope_size;
20902 }
20903
20904 let next_out_of_line = decoder.next_out_of_line();
20905 let handles_before = decoder.remaining_handles();
20906 if let Some((inlined, num_bytes, num_handles)) =
20907 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20908 {
20909 let member_inline_size =
20910 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20911 if inlined != (member_inline_size <= 4) {
20912 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20913 }
20914 let inner_offset;
20915 let mut inner_depth = depth.clone();
20916 if inlined {
20917 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20918 inner_offset = next_offset;
20919 } else {
20920 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20921 inner_depth.increment()?;
20922 }
20923 let val_ref = self
20924 .packet_count_for_client_max
20925 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20926 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20927 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20928 {
20929 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20930 }
20931 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20932 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20933 }
20934 }
20935
20936 next_offset += envelope_size;
20937 _next_ordinal_to_read += 1;
20938 if next_offset >= end_offset {
20939 return Ok(());
20940 }
20941
20942 while _next_ordinal_to_read < 12 {
20944 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20945 _next_ordinal_to_read += 1;
20946 next_offset += envelope_size;
20947 }
20948
20949 let next_out_of_line = decoder.next_out_of_line();
20950 let handles_before = decoder.remaining_handles();
20951 if let Some((inlined, num_bytes, num_handles)) =
20952 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20953 {
20954 let member_inline_size =
20955 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20956 if inlined != (member_inline_size <= 4) {
20957 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20958 }
20959 let inner_offset;
20960 let mut inner_depth = depth.clone();
20961 if inlined {
20962 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20963 inner_offset = next_offset;
20964 } else {
20965 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20966 inner_depth.increment()?;
20967 }
20968 let val_ref = self
20969 .single_buffer_mode_allowed
20970 .get_or_insert_with(|| fidl::new_empty!(bool, D));
20971 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
20972 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20973 {
20974 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20975 }
20976 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20977 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20978 }
20979 }
20980
20981 next_offset += envelope_size;
20982 _next_ordinal_to_read += 1;
20983 if next_offset >= end_offset {
20984 return Ok(());
20985 }
20986
20987 while _next_ordinal_to_read < 13 {
20989 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20990 _next_ordinal_to_read += 1;
20991 next_offset += envelope_size;
20992 }
20993
20994 let next_out_of_line = decoder.next_out_of_line();
20995 let handles_before = decoder.remaining_handles();
20996 if let Some((inlined, num_bytes, num_handles)) =
20997 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20998 {
20999 let member_inline_size =
21000 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21001 if inlined != (member_inline_size <= 4) {
21002 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21003 }
21004 let inner_offset;
21005 let mut inner_depth = depth.clone();
21006 if inlined {
21007 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21008 inner_offset = next_offset;
21009 } else {
21010 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21011 inner_depth.increment()?;
21012 }
21013 let val_ref = self
21014 .is_physically_contiguous_required
21015 .get_or_insert_with(|| fidl::new_empty!(bool, D));
21016 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21017 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21018 {
21019 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21020 }
21021 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21022 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21023 }
21024 }
21025
21026 next_offset += envelope_size;
21027
21028 while next_offset < end_offset {
21030 _next_ordinal_to_read += 1;
21031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21032 next_offset += envelope_size;
21033 }
21034
21035 Ok(())
21036 }
21037 }
21038
21039 impl StreamBufferSettings {
21040 #[inline(always)]
21041 fn max_ordinal_present(&self) -> u64 {
21042 if let Some(_) = self.single_buffer_mode {
21043 return 6;
21044 }
21045 if let Some(_) = self.per_packet_buffer_bytes {
21046 return 5;
21047 }
21048 if let Some(_) = self.packet_count_for_client {
21049 return 4;
21050 }
21051 if let Some(_) = self.packet_count_for_server {
21052 return 3;
21053 }
21054 if let Some(_) = self.buffer_constraints_version_ordinal {
21055 return 2;
21056 }
21057 if let Some(_) = self.buffer_lifetime_ordinal {
21058 return 1;
21059 }
21060 0
21061 }
21062 }
21063
21064 impl fidl::encoding::ValueTypeMarker for StreamBufferSettings {
21065 type Borrowed<'a> = &'a Self;
21066 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21067 value
21068 }
21069 }
21070
21071 unsafe impl fidl::encoding::TypeMarker for StreamBufferSettings {
21072 type Owned = Self;
21073
21074 #[inline(always)]
21075 fn inline_align(_context: fidl::encoding::Context) -> usize {
21076 8
21077 }
21078
21079 #[inline(always)]
21080 fn inline_size(_context: fidl::encoding::Context) -> usize {
21081 16
21082 }
21083 }
21084
21085 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamBufferSettings, D>
21086 for &StreamBufferSettings
21087 {
21088 unsafe fn encode(
21089 self,
21090 encoder: &mut fidl::encoding::Encoder<'_, D>,
21091 offset: usize,
21092 mut depth: fidl::encoding::Depth,
21093 ) -> fidl::Result<()> {
21094 encoder.debug_check_bounds::<StreamBufferSettings>(offset);
21095 let max_ordinal: u64 = self.max_ordinal_present();
21097 encoder.write_num(max_ordinal, offset);
21098 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21099 if max_ordinal == 0 {
21101 return Ok(());
21102 }
21103 depth.increment()?;
21104 let envelope_size = 8;
21105 let bytes_len = max_ordinal as usize * envelope_size;
21106 #[allow(unused_variables)]
21107 let offset = encoder.out_of_line_offset(bytes_len);
21108 let mut _prev_end_offset: usize = 0;
21109 if 1 > max_ordinal {
21110 return Ok(());
21111 }
21112
21113 let cur_offset: usize = (1 - 1) * envelope_size;
21116
21117 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21119
21120 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21125 self.buffer_lifetime_ordinal
21126 .as_ref()
21127 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21128 encoder,
21129 offset + cur_offset,
21130 depth,
21131 )?;
21132
21133 _prev_end_offset = cur_offset + envelope_size;
21134 if 2 > max_ordinal {
21135 return Ok(());
21136 }
21137
21138 let cur_offset: usize = (2 - 1) * envelope_size;
21141
21142 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21144
21145 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21150 self.buffer_constraints_version_ordinal
21151 .as_ref()
21152 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21153 encoder,
21154 offset + cur_offset,
21155 depth,
21156 )?;
21157
21158 _prev_end_offset = cur_offset + envelope_size;
21159 if 3 > max_ordinal {
21160 return Ok(());
21161 }
21162
21163 let cur_offset: usize = (3 - 1) * envelope_size;
21166
21167 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21169
21170 fidl::encoding::encode_in_envelope_optional::<u32, D>(
21175 self.packet_count_for_server
21176 .as_ref()
21177 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21178 encoder,
21179 offset + cur_offset,
21180 depth,
21181 )?;
21182
21183 _prev_end_offset = cur_offset + envelope_size;
21184 if 4 > max_ordinal {
21185 return Ok(());
21186 }
21187
21188 let cur_offset: usize = (4 - 1) * envelope_size;
21191
21192 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21194
21195 fidl::encoding::encode_in_envelope_optional::<u32, D>(
21200 self.packet_count_for_client
21201 .as_ref()
21202 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21203 encoder,
21204 offset + cur_offset,
21205 depth,
21206 )?;
21207
21208 _prev_end_offset = cur_offset + envelope_size;
21209 if 5 > max_ordinal {
21210 return Ok(());
21211 }
21212
21213 let cur_offset: usize = (5 - 1) * envelope_size;
21216
21217 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21219
21220 fidl::encoding::encode_in_envelope_optional::<u32, D>(
21225 self.per_packet_buffer_bytes
21226 .as_ref()
21227 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21228 encoder,
21229 offset + cur_offset,
21230 depth,
21231 )?;
21232
21233 _prev_end_offset = cur_offset + envelope_size;
21234 if 6 > max_ordinal {
21235 return Ok(());
21236 }
21237
21238 let cur_offset: usize = (6 - 1) * envelope_size;
21241
21242 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21244
21245 fidl::encoding::encode_in_envelope_optional::<bool, D>(
21250 self.single_buffer_mode
21251 .as_ref()
21252 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21253 encoder,
21254 offset + cur_offset,
21255 depth,
21256 )?;
21257
21258 _prev_end_offset = cur_offset + envelope_size;
21259
21260 Ok(())
21261 }
21262 }
21263
21264 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamBufferSettings {
21265 #[inline(always)]
21266 fn new_empty() -> Self {
21267 Self::default()
21268 }
21269
21270 unsafe fn decode(
21271 &mut self,
21272 decoder: &mut fidl::encoding::Decoder<'_, D>,
21273 offset: usize,
21274 mut depth: fidl::encoding::Depth,
21275 ) -> fidl::Result<()> {
21276 decoder.debug_check_bounds::<Self>(offset);
21277 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21278 None => return Err(fidl::Error::NotNullable),
21279 Some(len) => len,
21280 };
21281 if len == 0 {
21283 return Ok(());
21284 };
21285 depth.increment()?;
21286 let envelope_size = 8;
21287 let bytes_len = len * envelope_size;
21288 let offset = decoder.out_of_line_offset(bytes_len)?;
21289 let mut _next_ordinal_to_read = 0;
21291 let mut next_offset = offset;
21292 let end_offset = offset + bytes_len;
21293 _next_ordinal_to_read += 1;
21294 if next_offset >= end_offset {
21295 return Ok(());
21296 }
21297
21298 while _next_ordinal_to_read < 1 {
21300 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21301 _next_ordinal_to_read += 1;
21302 next_offset += envelope_size;
21303 }
21304
21305 let next_out_of_line = decoder.next_out_of_line();
21306 let handles_before = decoder.remaining_handles();
21307 if let Some((inlined, num_bytes, num_handles)) =
21308 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21309 {
21310 let member_inline_size =
21311 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21312 if inlined != (member_inline_size <= 4) {
21313 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21314 }
21315 let inner_offset;
21316 let mut inner_depth = depth.clone();
21317 if inlined {
21318 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21319 inner_offset = next_offset;
21320 } else {
21321 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21322 inner_depth.increment()?;
21323 }
21324 let val_ref =
21325 self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21326 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21327 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21328 {
21329 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21330 }
21331 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21332 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21333 }
21334 }
21335
21336 next_offset += envelope_size;
21337 _next_ordinal_to_read += 1;
21338 if next_offset >= end_offset {
21339 return Ok(());
21340 }
21341
21342 while _next_ordinal_to_read < 2 {
21344 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21345 _next_ordinal_to_read += 1;
21346 next_offset += envelope_size;
21347 }
21348
21349 let next_out_of_line = decoder.next_out_of_line();
21350 let handles_before = decoder.remaining_handles();
21351 if let Some((inlined, num_bytes, num_handles)) =
21352 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21353 {
21354 let member_inline_size =
21355 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21356 if inlined != (member_inline_size <= 4) {
21357 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21358 }
21359 let inner_offset;
21360 let mut inner_depth = depth.clone();
21361 if inlined {
21362 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21363 inner_offset = next_offset;
21364 } else {
21365 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21366 inner_depth.increment()?;
21367 }
21368 let val_ref = self
21369 .buffer_constraints_version_ordinal
21370 .get_or_insert_with(|| fidl::new_empty!(u64, D));
21371 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21373 {
21374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21375 }
21376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21378 }
21379 }
21380
21381 next_offset += envelope_size;
21382 _next_ordinal_to_read += 1;
21383 if next_offset >= end_offset {
21384 return Ok(());
21385 }
21386
21387 while _next_ordinal_to_read < 3 {
21389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21390 _next_ordinal_to_read += 1;
21391 next_offset += envelope_size;
21392 }
21393
21394 let next_out_of_line = decoder.next_out_of_line();
21395 let handles_before = decoder.remaining_handles();
21396 if let Some((inlined, num_bytes, num_handles)) =
21397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21398 {
21399 let member_inline_size =
21400 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21401 if inlined != (member_inline_size <= 4) {
21402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21403 }
21404 let inner_offset;
21405 let mut inner_depth = depth.clone();
21406 if inlined {
21407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21408 inner_offset = next_offset;
21409 } else {
21410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21411 inner_depth.increment()?;
21412 }
21413 let val_ref =
21414 self.packet_count_for_server.get_or_insert_with(|| fidl::new_empty!(u32, D));
21415 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21417 {
21418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21419 }
21420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21422 }
21423 }
21424
21425 next_offset += envelope_size;
21426 _next_ordinal_to_read += 1;
21427 if next_offset >= end_offset {
21428 return Ok(());
21429 }
21430
21431 while _next_ordinal_to_read < 4 {
21433 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21434 _next_ordinal_to_read += 1;
21435 next_offset += envelope_size;
21436 }
21437
21438 let next_out_of_line = decoder.next_out_of_line();
21439 let handles_before = decoder.remaining_handles();
21440 if let Some((inlined, num_bytes, num_handles)) =
21441 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21442 {
21443 let member_inline_size =
21444 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21445 if inlined != (member_inline_size <= 4) {
21446 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21447 }
21448 let inner_offset;
21449 let mut inner_depth = depth.clone();
21450 if inlined {
21451 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21452 inner_offset = next_offset;
21453 } else {
21454 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21455 inner_depth.increment()?;
21456 }
21457 let val_ref =
21458 self.packet_count_for_client.get_or_insert_with(|| fidl::new_empty!(u32, D));
21459 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21460 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21461 {
21462 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21463 }
21464 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21465 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21466 }
21467 }
21468
21469 next_offset += envelope_size;
21470 _next_ordinal_to_read += 1;
21471 if next_offset >= end_offset {
21472 return Ok(());
21473 }
21474
21475 while _next_ordinal_to_read < 5 {
21477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21478 _next_ordinal_to_read += 1;
21479 next_offset += envelope_size;
21480 }
21481
21482 let next_out_of_line = decoder.next_out_of_line();
21483 let handles_before = decoder.remaining_handles();
21484 if let Some((inlined, num_bytes, num_handles)) =
21485 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21486 {
21487 let member_inline_size =
21488 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21489 if inlined != (member_inline_size <= 4) {
21490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21491 }
21492 let inner_offset;
21493 let mut inner_depth = depth.clone();
21494 if inlined {
21495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21496 inner_offset = next_offset;
21497 } else {
21498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21499 inner_depth.increment()?;
21500 }
21501 let val_ref =
21502 self.per_packet_buffer_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
21503 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21504 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21505 {
21506 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21507 }
21508 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21509 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21510 }
21511 }
21512
21513 next_offset += envelope_size;
21514 _next_ordinal_to_read += 1;
21515 if next_offset >= end_offset {
21516 return Ok(());
21517 }
21518
21519 while _next_ordinal_to_read < 6 {
21521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21522 _next_ordinal_to_read += 1;
21523 next_offset += envelope_size;
21524 }
21525
21526 let next_out_of_line = decoder.next_out_of_line();
21527 let handles_before = decoder.remaining_handles();
21528 if let Some((inlined, num_bytes, num_handles)) =
21529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21530 {
21531 let member_inline_size =
21532 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21533 if inlined != (member_inline_size <= 4) {
21534 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21535 }
21536 let inner_offset;
21537 let mut inner_depth = depth.clone();
21538 if inlined {
21539 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21540 inner_offset = next_offset;
21541 } else {
21542 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21543 inner_depth.increment()?;
21544 }
21545 let val_ref =
21546 self.single_buffer_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
21547 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21548 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21549 {
21550 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21551 }
21552 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21553 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21554 }
21555 }
21556
21557 next_offset += envelope_size;
21558
21559 while next_offset < end_offset {
21561 _next_ordinal_to_read += 1;
21562 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21563 next_offset += envelope_size;
21564 }
21565
21566 Ok(())
21567 }
21568 }
21569
21570 impl StreamOutputConstraints {
21571 #[inline(always)]
21572 fn max_ordinal_present(&self) -> u64 {
21573 if let Some(_) = self.buffer_constraints {
21574 return 3;
21575 }
21576 if let Some(_) = self.buffer_constraints_action_required {
21577 return 2;
21578 }
21579 if let Some(_) = self.stream_lifetime_ordinal {
21580 return 1;
21581 }
21582 0
21583 }
21584 }
21585
21586 impl fidl::encoding::ValueTypeMarker for StreamOutputConstraints {
21587 type Borrowed<'a> = &'a Self;
21588 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21589 value
21590 }
21591 }
21592
21593 unsafe impl fidl::encoding::TypeMarker for StreamOutputConstraints {
21594 type Owned = Self;
21595
21596 #[inline(always)]
21597 fn inline_align(_context: fidl::encoding::Context) -> usize {
21598 8
21599 }
21600
21601 #[inline(always)]
21602 fn inline_size(_context: fidl::encoding::Context) -> usize {
21603 16
21604 }
21605 }
21606
21607 unsafe impl<D: fidl::encoding::ResourceDialect>
21608 fidl::encoding::Encode<StreamOutputConstraints, D> for &StreamOutputConstraints
21609 {
21610 unsafe fn encode(
21611 self,
21612 encoder: &mut fidl::encoding::Encoder<'_, D>,
21613 offset: usize,
21614 mut depth: fidl::encoding::Depth,
21615 ) -> fidl::Result<()> {
21616 encoder.debug_check_bounds::<StreamOutputConstraints>(offset);
21617 let max_ordinal: u64 = self.max_ordinal_present();
21619 encoder.write_num(max_ordinal, offset);
21620 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21621 if max_ordinal == 0 {
21623 return Ok(());
21624 }
21625 depth.increment()?;
21626 let envelope_size = 8;
21627 let bytes_len = max_ordinal as usize * envelope_size;
21628 #[allow(unused_variables)]
21629 let offset = encoder.out_of_line_offset(bytes_len);
21630 let mut _prev_end_offset: usize = 0;
21631 if 1 > max_ordinal {
21632 return Ok(());
21633 }
21634
21635 let cur_offset: usize = (1 - 1) * envelope_size;
21638
21639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21641
21642 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21647 self.stream_lifetime_ordinal
21648 .as_ref()
21649 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21650 encoder,
21651 offset + cur_offset,
21652 depth,
21653 )?;
21654
21655 _prev_end_offset = cur_offset + envelope_size;
21656 if 2 > max_ordinal {
21657 return Ok(());
21658 }
21659
21660 let cur_offset: usize = (2 - 1) * envelope_size;
21663
21664 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21666
21667 fidl::encoding::encode_in_envelope_optional::<bool, D>(
21672 self.buffer_constraints_action_required
21673 .as_ref()
21674 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21675 encoder,
21676 offset + cur_offset,
21677 depth,
21678 )?;
21679
21680 _prev_end_offset = cur_offset + envelope_size;
21681 if 3 > max_ordinal {
21682 return Ok(());
21683 }
21684
21685 let cur_offset: usize = (3 - 1) * envelope_size;
21688
21689 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21691
21692 fidl::encoding::encode_in_envelope_optional::<StreamBufferConstraints, D>(
21697 self.buffer_constraints
21698 .as_ref()
21699 .map(<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow),
21700 encoder,
21701 offset + cur_offset,
21702 depth,
21703 )?;
21704
21705 _prev_end_offset = cur_offset + envelope_size;
21706
21707 Ok(())
21708 }
21709 }
21710
21711 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
21712 for StreamOutputConstraints
21713 {
21714 #[inline(always)]
21715 fn new_empty() -> Self {
21716 Self::default()
21717 }
21718
21719 unsafe fn decode(
21720 &mut self,
21721 decoder: &mut fidl::encoding::Decoder<'_, D>,
21722 offset: usize,
21723 mut depth: fidl::encoding::Depth,
21724 ) -> fidl::Result<()> {
21725 decoder.debug_check_bounds::<Self>(offset);
21726 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21727 None => return Err(fidl::Error::NotNullable),
21728 Some(len) => len,
21729 };
21730 if len == 0 {
21732 return Ok(());
21733 };
21734 depth.increment()?;
21735 let envelope_size = 8;
21736 let bytes_len = len * envelope_size;
21737 let offset = decoder.out_of_line_offset(bytes_len)?;
21738 let mut _next_ordinal_to_read = 0;
21740 let mut next_offset = offset;
21741 let end_offset = offset + bytes_len;
21742 _next_ordinal_to_read += 1;
21743 if next_offset >= end_offset {
21744 return Ok(());
21745 }
21746
21747 while _next_ordinal_to_read < 1 {
21749 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21750 _next_ordinal_to_read += 1;
21751 next_offset += envelope_size;
21752 }
21753
21754 let next_out_of_line = decoder.next_out_of_line();
21755 let handles_before = decoder.remaining_handles();
21756 if let Some((inlined, num_bytes, num_handles)) =
21757 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21758 {
21759 let member_inline_size =
21760 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21761 if inlined != (member_inline_size <= 4) {
21762 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21763 }
21764 let inner_offset;
21765 let mut inner_depth = depth.clone();
21766 if inlined {
21767 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21768 inner_offset = next_offset;
21769 } else {
21770 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21771 inner_depth.increment()?;
21772 }
21773 let val_ref =
21774 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21775 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21776 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21777 {
21778 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21779 }
21780 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21781 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21782 }
21783 }
21784
21785 next_offset += envelope_size;
21786 _next_ordinal_to_read += 1;
21787 if next_offset >= end_offset {
21788 return Ok(());
21789 }
21790
21791 while _next_ordinal_to_read < 2 {
21793 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21794 _next_ordinal_to_read += 1;
21795 next_offset += envelope_size;
21796 }
21797
21798 let next_out_of_line = decoder.next_out_of_line();
21799 let handles_before = decoder.remaining_handles();
21800 if let Some((inlined, num_bytes, num_handles)) =
21801 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21802 {
21803 let member_inline_size =
21804 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21805 if inlined != (member_inline_size <= 4) {
21806 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21807 }
21808 let inner_offset;
21809 let mut inner_depth = depth.clone();
21810 if inlined {
21811 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21812 inner_offset = next_offset;
21813 } else {
21814 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21815 inner_depth.increment()?;
21816 }
21817 let val_ref = self
21818 .buffer_constraints_action_required
21819 .get_or_insert_with(|| fidl::new_empty!(bool, D));
21820 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21821 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21822 {
21823 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21824 }
21825 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21826 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21827 }
21828 }
21829
21830 next_offset += envelope_size;
21831 _next_ordinal_to_read += 1;
21832 if next_offset >= end_offset {
21833 return Ok(());
21834 }
21835
21836 while _next_ordinal_to_read < 3 {
21838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21839 _next_ordinal_to_read += 1;
21840 next_offset += envelope_size;
21841 }
21842
21843 let next_out_of_line = decoder.next_out_of_line();
21844 let handles_before = decoder.remaining_handles();
21845 if let Some((inlined, num_bytes, num_handles)) =
21846 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21847 {
21848 let member_inline_size =
21849 <StreamBufferConstraints as fidl::encoding::TypeMarker>::inline_size(
21850 decoder.context,
21851 );
21852 if inlined != (member_inline_size <= 4) {
21853 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21854 }
21855 let inner_offset;
21856 let mut inner_depth = depth.clone();
21857 if inlined {
21858 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21859 inner_offset = next_offset;
21860 } else {
21861 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21862 inner_depth.increment()?;
21863 }
21864 let val_ref = self
21865 .buffer_constraints
21866 .get_or_insert_with(|| fidl::new_empty!(StreamBufferConstraints, D));
21867 fidl::decode!(
21868 StreamBufferConstraints,
21869 D,
21870 val_ref,
21871 decoder,
21872 inner_offset,
21873 inner_depth
21874 )?;
21875 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21876 {
21877 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21878 }
21879 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21880 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21881 }
21882 }
21883
21884 next_offset += envelope_size;
21885
21886 while next_offset < end_offset {
21888 _next_ordinal_to_read += 1;
21889 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21890 next_offset += envelope_size;
21891 }
21892
21893 Ok(())
21894 }
21895 }
21896
21897 impl StreamOutputFormat {
21898 #[inline(always)]
21899 fn max_ordinal_present(&self) -> u64 {
21900 if let Some(_) = self.format_details {
21901 return 2;
21902 }
21903 if let Some(_) = self.stream_lifetime_ordinal {
21904 return 1;
21905 }
21906 0
21907 }
21908 }
21909
21910 impl fidl::encoding::ValueTypeMarker for StreamOutputFormat {
21911 type Borrowed<'a> = &'a Self;
21912 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21913 value
21914 }
21915 }
21916
21917 unsafe impl fidl::encoding::TypeMarker for StreamOutputFormat {
21918 type Owned = Self;
21919
21920 #[inline(always)]
21921 fn inline_align(_context: fidl::encoding::Context) -> usize {
21922 8
21923 }
21924
21925 #[inline(always)]
21926 fn inline_size(_context: fidl::encoding::Context) -> usize {
21927 16
21928 }
21929 }
21930
21931 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamOutputFormat, D>
21932 for &StreamOutputFormat
21933 {
21934 unsafe fn encode(
21935 self,
21936 encoder: &mut fidl::encoding::Encoder<'_, D>,
21937 offset: usize,
21938 mut depth: fidl::encoding::Depth,
21939 ) -> fidl::Result<()> {
21940 encoder.debug_check_bounds::<StreamOutputFormat>(offset);
21941 let max_ordinal: u64 = self.max_ordinal_present();
21943 encoder.write_num(max_ordinal, offset);
21944 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21945 if max_ordinal == 0 {
21947 return Ok(());
21948 }
21949 depth.increment()?;
21950 let envelope_size = 8;
21951 let bytes_len = max_ordinal as usize * envelope_size;
21952 #[allow(unused_variables)]
21953 let offset = encoder.out_of_line_offset(bytes_len);
21954 let mut _prev_end_offset: usize = 0;
21955 if 1 > max_ordinal {
21956 return Ok(());
21957 }
21958
21959 let cur_offset: usize = (1 - 1) * envelope_size;
21962
21963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21965
21966 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21971 self.stream_lifetime_ordinal
21972 .as_ref()
21973 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21974 encoder,
21975 offset + cur_offset,
21976 depth,
21977 )?;
21978
21979 _prev_end_offset = cur_offset + envelope_size;
21980 if 2 > max_ordinal {
21981 return Ok(());
21982 }
21983
21984 let cur_offset: usize = (2 - 1) * envelope_size;
21987
21988 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21990
21991 fidl::encoding::encode_in_envelope_optional::<FormatDetails, D>(
21996 self.format_details
21997 .as_ref()
21998 .map(<FormatDetails as fidl::encoding::ValueTypeMarker>::borrow),
21999 encoder,
22000 offset + cur_offset,
22001 depth,
22002 )?;
22003
22004 _prev_end_offset = cur_offset + envelope_size;
22005
22006 Ok(())
22007 }
22008 }
22009
22010 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamOutputFormat {
22011 #[inline(always)]
22012 fn new_empty() -> Self {
22013 Self::default()
22014 }
22015
22016 unsafe fn decode(
22017 &mut self,
22018 decoder: &mut fidl::encoding::Decoder<'_, D>,
22019 offset: usize,
22020 mut depth: fidl::encoding::Depth,
22021 ) -> fidl::Result<()> {
22022 decoder.debug_check_bounds::<Self>(offset);
22023 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22024 None => return Err(fidl::Error::NotNullable),
22025 Some(len) => len,
22026 };
22027 if len == 0 {
22029 return Ok(());
22030 };
22031 depth.increment()?;
22032 let envelope_size = 8;
22033 let bytes_len = len * envelope_size;
22034 let offset = decoder.out_of_line_offset(bytes_len)?;
22035 let mut _next_ordinal_to_read = 0;
22037 let mut next_offset = offset;
22038 let end_offset = offset + bytes_len;
22039 _next_ordinal_to_read += 1;
22040 if next_offset >= end_offset {
22041 return Ok(());
22042 }
22043
22044 while _next_ordinal_to_read < 1 {
22046 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22047 _next_ordinal_to_read += 1;
22048 next_offset += envelope_size;
22049 }
22050
22051 let next_out_of_line = decoder.next_out_of_line();
22052 let handles_before = decoder.remaining_handles();
22053 if let Some((inlined, num_bytes, num_handles)) =
22054 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22055 {
22056 let member_inline_size =
22057 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22058 if inlined != (member_inline_size <= 4) {
22059 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22060 }
22061 let inner_offset;
22062 let mut inner_depth = depth.clone();
22063 if inlined {
22064 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22065 inner_offset = next_offset;
22066 } else {
22067 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22068 inner_depth.increment()?;
22069 }
22070 let val_ref =
22071 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
22072 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
22073 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22074 {
22075 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22076 }
22077 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22078 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22079 }
22080 }
22081
22082 next_offset += envelope_size;
22083 _next_ordinal_to_read += 1;
22084 if next_offset >= end_offset {
22085 return Ok(());
22086 }
22087
22088 while _next_ordinal_to_read < 2 {
22090 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22091 _next_ordinal_to_read += 1;
22092 next_offset += envelope_size;
22093 }
22094
22095 let next_out_of_line = decoder.next_out_of_line();
22096 let handles_before = decoder.remaining_handles();
22097 if let Some((inlined, num_bytes, num_handles)) =
22098 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22099 {
22100 let member_inline_size =
22101 <FormatDetails as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22102 if inlined != (member_inline_size <= 4) {
22103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22104 }
22105 let inner_offset;
22106 let mut inner_depth = depth.clone();
22107 if inlined {
22108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22109 inner_offset = next_offset;
22110 } else {
22111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22112 inner_depth.increment()?;
22113 }
22114 let val_ref =
22115 self.format_details.get_or_insert_with(|| fidl::new_empty!(FormatDetails, D));
22116 fidl::decode!(FormatDetails, D, val_ref, decoder, inner_offset, inner_depth)?;
22117 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22118 {
22119 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22120 }
22121 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22122 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22123 }
22124 }
22125
22126 next_offset += envelope_size;
22127
22128 while next_offset < end_offset {
22130 _next_ordinal_to_read += 1;
22131 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22132 next_offset += envelope_size;
22133 }
22134
22135 Ok(())
22136 }
22137 }
22138
22139 impl UsageStateDucked {
22140 #[inline(always)]
22141 fn max_ordinal_present(&self) -> u64 {
22142 0
22143 }
22144 }
22145
22146 impl fidl::encoding::ValueTypeMarker for UsageStateDucked {
22147 type Borrowed<'a> = &'a Self;
22148 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22149 value
22150 }
22151 }
22152
22153 unsafe impl fidl::encoding::TypeMarker for UsageStateDucked {
22154 type Owned = Self;
22155
22156 #[inline(always)]
22157 fn inline_align(_context: fidl::encoding::Context) -> usize {
22158 8
22159 }
22160
22161 #[inline(always)]
22162 fn inline_size(_context: fidl::encoding::Context) -> usize {
22163 16
22164 }
22165 }
22166
22167 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateDucked, D>
22168 for &UsageStateDucked
22169 {
22170 unsafe fn encode(
22171 self,
22172 encoder: &mut fidl::encoding::Encoder<'_, D>,
22173 offset: usize,
22174 mut depth: fidl::encoding::Depth,
22175 ) -> fidl::Result<()> {
22176 encoder.debug_check_bounds::<UsageStateDucked>(offset);
22177 let max_ordinal: u64 = self.max_ordinal_present();
22179 encoder.write_num(max_ordinal, offset);
22180 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22181 if max_ordinal == 0 {
22183 return Ok(());
22184 }
22185 depth.increment()?;
22186 let envelope_size = 8;
22187 let bytes_len = max_ordinal as usize * envelope_size;
22188 #[allow(unused_variables)]
22189 let offset = encoder.out_of_line_offset(bytes_len);
22190 let mut _prev_end_offset: usize = 0;
22191
22192 Ok(())
22193 }
22194 }
22195
22196 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateDucked {
22197 #[inline(always)]
22198 fn new_empty() -> Self {
22199 Self::default()
22200 }
22201
22202 unsafe fn decode(
22203 &mut self,
22204 decoder: &mut fidl::encoding::Decoder<'_, D>,
22205 offset: usize,
22206 mut depth: fidl::encoding::Depth,
22207 ) -> fidl::Result<()> {
22208 decoder.debug_check_bounds::<Self>(offset);
22209 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22210 None => return Err(fidl::Error::NotNullable),
22211 Some(len) => len,
22212 };
22213 if len == 0 {
22215 return Ok(());
22216 };
22217 depth.increment()?;
22218 let envelope_size = 8;
22219 let bytes_len = len * envelope_size;
22220 let offset = decoder.out_of_line_offset(bytes_len)?;
22221 let mut _next_ordinal_to_read = 0;
22223 let mut next_offset = offset;
22224 let end_offset = offset + bytes_len;
22225
22226 while next_offset < end_offset {
22228 _next_ordinal_to_read += 1;
22229 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22230 next_offset += envelope_size;
22231 }
22232
22233 Ok(())
22234 }
22235 }
22236
22237 impl UsageStateMuted {
22238 #[inline(always)]
22239 fn max_ordinal_present(&self) -> u64 {
22240 0
22241 }
22242 }
22243
22244 impl fidl::encoding::ValueTypeMarker for UsageStateMuted {
22245 type Borrowed<'a> = &'a Self;
22246 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22247 value
22248 }
22249 }
22250
22251 unsafe impl fidl::encoding::TypeMarker for UsageStateMuted {
22252 type Owned = Self;
22253
22254 #[inline(always)]
22255 fn inline_align(_context: fidl::encoding::Context) -> usize {
22256 8
22257 }
22258
22259 #[inline(always)]
22260 fn inline_size(_context: fidl::encoding::Context) -> usize {
22261 16
22262 }
22263 }
22264
22265 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateMuted, D>
22266 for &UsageStateMuted
22267 {
22268 unsafe fn encode(
22269 self,
22270 encoder: &mut fidl::encoding::Encoder<'_, D>,
22271 offset: usize,
22272 mut depth: fidl::encoding::Depth,
22273 ) -> fidl::Result<()> {
22274 encoder.debug_check_bounds::<UsageStateMuted>(offset);
22275 let max_ordinal: u64 = self.max_ordinal_present();
22277 encoder.write_num(max_ordinal, offset);
22278 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22279 if max_ordinal == 0 {
22281 return Ok(());
22282 }
22283 depth.increment()?;
22284 let envelope_size = 8;
22285 let bytes_len = max_ordinal as usize * envelope_size;
22286 #[allow(unused_variables)]
22287 let offset = encoder.out_of_line_offset(bytes_len);
22288 let mut _prev_end_offset: usize = 0;
22289
22290 Ok(())
22291 }
22292 }
22293
22294 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateMuted {
22295 #[inline(always)]
22296 fn new_empty() -> Self {
22297 Self::default()
22298 }
22299
22300 unsafe fn decode(
22301 &mut self,
22302 decoder: &mut fidl::encoding::Decoder<'_, D>,
22303 offset: usize,
22304 mut depth: fidl::encoding::Depth,
22305 ) -> fidl::Result<()> {
22306 decoder.debug_check_bounds::<Self>(offset);
22307 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22308 None => return Err(fidl::Error::NotNullable),
22309 Some(len) => len,
22310 };
22311 if len == 0 {
22313 return Ok(());
22314 };
22315 depth.increment()?;
22316 let envelope_size = 8;
22317 let bytes_len = len * envelope_size;
22318 let offset = decoder.out_of_line_offset(bytes_len)?;
22319 let mut _next_ordinal_to_read = 0;
22321 let mut next_offset = offset;
22322 let end_offset = offset + bytes_len;
22323
22324 while next_offset < end_offset {
22326 _next_ordinal_to_read += 1;
22327 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22328 next_offset += envelope_size;
22329 }
22330
22331 Ok(())
22332 }
22333 }
22334
22335 impl UsageStateUnadjusted {
22336 #[inline(always)]
22337 fn max_ordinal_present(&self) -> u64 {
22338 0
22339 }
22340 }
22341
22342 impl fidl::encoding::ValueTypeMarker for UsageStateUnadjusted {
22343 type Borrowed<'a> = &'a Self;
22344 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22345 value
22346 }
22347 }
22348
22349 unsafe impl fidl::encoding::TypeMarker for UsageStateUnadjusted {
22350 type Owned = Self;
22351
22352 #[inline(always)]
22353 fn inline_align(_context: fidl::encoding::Context) -> usize {
22354 8
22355 }
22356
22357 #[inline(always)]
22358 fn inline_size(_context: fidl::encoding::Context) -> usize {
22359 16
22360 }
22361 }
22362
22363 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateUnadjusted, D>
22364 for &UsageStateUnadjusted
22365 {
22366 unsafe fn encode(
22367 self,
22368 encoder: &mut fidl::encoding::Encoder<'_, D>,
22369 offset: usize,
22370 mut depth: fidl::encoding::Depth,
22371 ) -> fidl::Result<()> {
22372 encoder.debug_check_bounds::<UsageStateUnadjusted>(offset);
22373 let max_ordinal: u64 = self.max_ordinal_present();
22375 encoder.write_num(max_ordinal, offset);
22376 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22377 if max_ordinal == 0 {
22379 return Ok(());
22380 }
22381 depth.increment()?;
22382 let envelope_size = 8;
22383 let bytes_len = max_ordinal as usize * envelope_size;
22384 #[allow(unused_variables)]
22385 let offset = encoder.out_of_line_offset(bytes_len);
22386 let mut _prev_end_offset: usize = 0;
22387
22388 Ok(())
22389 }
22390 }
22391
22392 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateUnadjusted {
22393 #[inline(always)]
22394 fn new_empty() -> Self {
22395 Self::default()
22396 }
22397
22398 unsafe fn decode(
22399 &mut self,
22400 decoder: &mut fidl::encoding::Decoder<'_, D>,
22401 offset: usize,
22402 mut depth: fidl::encoding::Depth,
22403 ) -> fidl::Result<()> {
22404 decoder.debug_check_bounds::<Self>(offset);
22405 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22406 None => return Err(fidl::Error::NotNullable),
22407 Some(len) => len,
22408 };
22409 if len == 0 {
22411 return Ok(());
22412 };
22413 depth.increment()?;
22414 let envelope_size = 8;
22415 let bytes_len = len * envelope_size;
22416 let offset = decoder.out_of_line_offset(bytes_len)?;
22417 let mut _next_ordinal_to_read = 0;
22419 let mut next_offset = offset;
22420 let end_offset = offset + bytes_len;
22421
22422 while next_offset < end_offset {
22424 _next_ordinal_to_read += 1;
22425 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22426 next_offset += envelope_size;
22427 }
22428
22429 Ok(())
22430 }
22431 }
22432
22433 impl fidl::encoding::ValueTypeMarker for AacBitRate {
22434 type Borrowed<'a> = &'a Self;
22435 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22436 value
22437 }
22438 }
22439
22440 unsafe impl fidl::encoding::TypeMarker for AacBitRate {
22441 type Owned = Self;
22442
22443 #[inline(always)]
22444 fn inline_align(_context: fidl::encoding::Context) -> usize {
22445 8
22446 }
22447
22448 #[inline(always)]
22449 fn inline_size(_context: fidl::encoding::Context) -> usize {
22450 16
22451 }
22452 }
22453
22454 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacBitRate, D>
22455 for &AacBitRate
22456 {
22457 #[inline]
22458 unsafe fn encode(
22459 self,
22460 encoder: &mut fidl::encoding::Encoder<'_, D>,
22461 offset: usize,
22462 _depth: fidl::encoding::Depth,
22463 ) -> fidl::Result<()> {
22464 encoder.debug_check_bounds::<AacBitRate>(offset);
22465 encoder.write_num::<u64>(self.ordinal(), offset);
22466 match self {
22467 AacBitRate::Constant(ref val) => {
22468 fidl::encoding::encode_in_envelope::<AacConstantBitRate, D>(
22469 <AacConstantBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22470 encoder,
22471 offset + 8,
22472 _depth,
22473 )
22474 }
22475 AacBitRate::Variable(ref val) => {
22476 fidl::encoding::encode_in_envelope::<AacVariableBitRate, D>(
22477 <AacVariableBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22478 encoder,
22479 offset + 8,
22480 _depth,
22481 )
22482 }
22483 }
22484 }
22485 }
22486
22487 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacBitRate {
22488 #[inline(always)]
22489 fn new_empty() -> Self {
22490 Self::Constant(fidl::new_empty!(AacConstantBitRate, D))
22491 }
22492
22493 #[inline]
22494 unsafe fn decode(
22495 &mut self,
22496 decoder: &mut fidl::encoding::Decoder<'_, D>,
22497 offset: usize,
22498 mut depth: fidl::encoding::Depth,
22499 ) -> fidl::Result<()> {
22500 decoder.debug_check_bounds::<Self>(offset);
22501 #[allow(unused_variables)]
22502 let next_out_of_line = decoder.next_out_of_line();
22503 let handles_before = decoder.remaining_handles();
22504 let (ordinal, inlined, num_bytes, num_handles) =
22505 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22506
22507 let member_inline_size = match ordinal {
22508 1 => {
22509 <AacConstantBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22510 }
22511 2 => {
22512 <AacVariableBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22513 }
22514 _ => return Err(fidl::Error::UnknownUnionTag),
22515 };
22516
22517 if inlined != (member_inline_size <= 4) {
22518 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22519 }
22520 let _inner_offset;
22521 if inlined {
22522 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22523 _inner_offset = offset + 8;
22524 } else {
22525 depth.increment()?;
22526 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22527 }
22528 match ordinal {
22529 1 => {
22530 #[allow(irrefutable_let_patterns)]
22531 if let AacBitRate::Constant(_) = self {
22532 } else {
22534 *self = AacBitRate::Constant(fidl::new_empty!(AacConstantBitRate, D));
22536 }
22537 #[allow(irrefutable_let_patterns)]
22538 if let AacBitRate::Constant(ref mut val) = self {
22539 fidl::decode!(AacConstantBitRate, D, val, decoder, _inner_offset, depth)?;
22540 } else {
22541 unreachable!()
22542 }
22543 }
22544 2 => {
22545 #[allow(irrefutable_let_patterns)]
22546 if let AacBitRate::Variable(_) = self {
22547 } else {
22549 *self = AacBitRate::Variable(fidl::new_empty!(AacVariableBitRate, D));
22551 }
22552 #[allow(irrefutable_let_patterns)]
22553 if let AacBitRate::Variable(ref mut val) = self {
22554 fidl::decode!(AacVariableBitRate, D, val, decoder, _inner_offset, depth)?;
22555 } else {
22556 unreachable!()
22557 }
22558 }
22559 ordinal => panic!("unexpected ordinal {:?}", ordinal),
22560 }
22561 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22562 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22563 }
22564 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22565 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22566 }
22567 Ok(())
22568 }
22569 }
22570
22571 impl fidl::encoding::ValueTypeMarker for AacTransport {
22572 type Borrowed<'a> = &'a Self;
22573 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22574 value
22575 }
22576 }
22577
22578 unsafe impl fidl::encoding::TypeMarker for AacTransport {
22579 type Owned = Self;
22580
22581 #[inline(always)]
22582 fn inline_align(_context: fidl::encoding::Context) -> usize {
22583 8
22584 }
22585
22586 #[inline(always)]
22587 fn inline_size(_context: fidl::encoding::Context) -> usize {
22588 16
22589 }
22590 }
22591
22592 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransport, D>
22593 for &AacTransport
22594 {
22595 #[inline]
22596 unsafe fn encode(
22597 self,
22598 encoder: &mut fidl::encoding::Encoder<'_, D>,
22599 offset: usize,
22600 _depth: fidl::encoding::Depth,
22601 ) -> fidl::Result<()> {
22602 encoder.debug_check_bounds::<AacTransport>(offset);
22603 encoder.write_num::<u64>(self.ordinal(), offset);
22604 match self {
22605 AacTransport::Raw(ref val) => {
22606 fidl::encoding::encode_in_envelope::<AacTransportRaw, D>(
22607 <AacTransportRaw as fidl::encoding::ValueTypeMarker>::borrow(val),
22608 encoder,
22609 offset + 8,
22610 _depth,
22611 )
22612 }
22613 AacTransport::Latm(ref val) => {
22614 fidl::encoding::encode_in_envelope::<AacTransportLatm, D>(
22615 <AacTransportLatm as fidl::encoding::ValueTypeMarker>::borrow(val),
22616 encoder,
22617 offset + 8,
22618 _depth,
22619 )
22620 }
22621 AacTransport::Adts(ref val) => {
22622 fidl::encoding::encode_in_envelope::<AacTransportAdts, D>(
22623 <AacTransportAdts as fidl::encoding::ValueTypeMarker>::borrow(val),
22624 encoder,
22625 offset + 8,
22626 _depth,
22627 )
22628 }
22629 AacTransport::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22630 }
22631 }
22632 }
22633
22634 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransport {
22635 #[inline(always)]
22636 fn new_empty() -> Self {
22637 Self::__SourceBreaking { unknown_ordinal: 0 }
22638 }
22639
22640 #[inline]
22641 unsafe fn decode(
22642 &mut self,
22643 decoder: &mut fidl::encoding::Decoder<'_, D>,
22644 offset: usize,
22645 mut depth: fidl::encoding::Depth,
22646 ) -> fidl::Result<()> {
22647 decoder.debug_check_bounds::<Self>(offset);
22648 #[allow(unused_variables)]
22649 let next_out_of_line = decoder.next_out_of_line();
22650 let handles_before = decoder.remaining_handles();
22651 let (ordinal, inlined, num_bytes, num_handles) =
22652 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22653
22654 let member_inline_size = match ordinal {
22655 1 => <AacTransportRaw as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22656 2 => <AacTransportLatm as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22657 3 => <AacTransportAdts as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22658 0 => return Err(fidl::Error::UnknownUnionTag),
22659 _ => num_bytes as usize,
22660 };
22661
22662 if inlined != (member_inline_size <= 4) {
22663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22664 }
22665 let _inner_offset;
22666 if inlined {
22667 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22668 _inner_offset = offset + 8;
22669 } else {
22670 depth.increment()?;
22671 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22672 }
22673 match ordinal {
22674 1 => {
22675 #[allow(irrefutable_let_patterns)]
22676 if let AacTransport::Raw(_) = self {
22677 } else {
22679 *self = AacTransport::Raw(fidl::new_empty!(AacTransportRaw, D));
22681 }
22682 #[allow(irrefutable_let_patterns)]
22683 if let AacTransport::Raw(ref mut val) = self {
22684 fidl::decode!(AacTransportRaw, D, val, decoder, _inner_offset, depth)?;
22685 } else {
22686 unreachable!()
22687 }
22688 }
22689 2 => {
22690 #[allow(irrefutable_let_patterns)]
22691 if let AacTransport::Latm(_) = self {
22692 } else {
22694 *self = AacTransport::Latm(fidl::new_empty!(AacTransportLatm, D));
22696 }
22697 #[allow(irrefutable_let_patterns)]
22698 if let AacTransport::Latm(ref mut val) = self {
22699 fidl::decode!(AacTransportLatm, D, val, decoder, _inner_offset, depth)?;
22700 } else {
22701 unreachable!()
22702 }
22703 }
22704 3 => {
22705 #[allow(irrefutable_let_patterns)]
22706 if let AacTransport::Adts(_) = self {
22707 } else {
22709 *self = AacTransport::Adts(fidl::new_empty!(AacTransportAdts, D));
22711 }
22712 #[allow(irrefutable_let_patterns)]
22713 if let AacTransport::Adts(ref mut val) = self {
22714 fidl::decode!(AacTransportAdts, D, val, decoder, _inner_offset, depth)?;
22715 } else {
22716 unreachable!()
22717 }
22718 }
22719 #[allow(deprecated)]
22720 ordinal => {
22721 for _ in 0..num_handles {
22722 decoder.drop_next_handle()?;
22723 }
22724 *self = AacTransport::__SourceBreaking { unknown_ordinal: ordinal };
22725 }
22726 }
22727 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22728 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22729 }
22730 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22731 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22732 }
22733 Ok(())
22734 }
22735 }
22736
22737 impl fidl::encoding::ValueTypeMarker for AudioCapturerConfiguration {
22738 type Borrowed<'a> = &'a Self;
22739 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22740 value
22741 }
22742 }
22743
22744 unsafe impl fidl::encoding::TypeMarker for AudioCapturerConfiguration {
22745 type Owned = Self;
22746
22747 #[inline(always)]
22748 fn inline_align(_context: fidl::encoding::Context) -> usize {
22749 8
22750 }
22751
22752 #[inline(always)]
22753 fn inline_size(_context: fidl::encoding::Context) -> usize {
22754 16
22755 }
22756 }
22757
22758 unsafe impl<D: fidl::encoding::ResourceDialect>
22759 fidl::encoding::Encode<AudioCapturerConfiguration, D> for &AudioCapturerConfiguration
22760 {
22761 #[inline]
22762 unsafe fn encode(
22763 self,
22764 encoder: &mut fidl::encoding::Encoder<'_, D>,
22765 offset: usize,
22766 _depth: fidl::encoding::Depth,
22767 ) -> fidl::Result<()> {
22768 encoder.debug_check_bounds::<AudioCapturerConfiguration>(offset);
22769 encoder.write_num::<u64>(self.ordinal(), offset);
22770 match self {
22771 AudioCapturerConfiguration::Loopback(ref val) => fidl::encoding::encode_in_envelope::<
22772 LoopbackAudioCapturerConfiguration,
22773 D,
22774 >(
22775 <LoopbackAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22776 val,
22777 ),
22778 encoder,
22779 offset + 8,
22780 _depth,
22781 ),
22782 AudioCapturerConfiguration::Input(ref val) => fidl::encoding::encode_in_envelope::<
22783 InputAudioCapturerConfiguration,
22784 D,
22785 >(
22786 <InputAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22787 val,
22788 ),
22789 encoder,
22790 offset + 8,
22791 _depth,
22792 ),
22793 }
22794 }
22795 }
22796
22797 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
22798 for AudioCapturerConfiguration
22799 {
22800 #[inline(always)]
22801 fn new_empty() -> Self {
22802 Self::Loopback(fidl::new_empty!(LoopbackAudioCapturerConfiguration, D))
22803 }
22804
22805 #[inline]
22806 unsafe fn decode(
22807 &mut self,
22808 decoder: &mut fidl::encoding::Decoder<'_, D>,
22809 offset: usize,
22810 mut depth: fidl::encoding::Depth,
22811 ) -> fidl::Result<()> {
22812 decoder.debug_check_bounds::<Self>(offset);
22813 #[allow(unused_variables)]
22814 let next_out_of_line = decoder.next_out_of_line();
22815 let handles_before = decoder.remaining_handles();
22816 let (ordinal, inlined, num_bytes, num_handles) =
22817 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22818
22819 let member_inline_size = match ordinal {
22820 1 => {
22821 <LoopbackAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22822 decoder.context,
22823 )
22824 }
22825 2 => <InputAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22826 decoder.context,
22827 ),
22828 _ => return Err(fidl::Error::UnknownUnionTag),
22829 };
22830
22831 if inlined != (member_inline_size <= 4) {
22832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22833 }
22834 let _inner_offset;
22835 if inlined {
22836 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22837 _inner_offset = offset + 8;
22838 } else {
22839 depth.increment()?;
22840 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22841 }
22842 match ordinal {
22843 1 => {
22844 #[allow(irrefutable_let_patterns)]
22845 if let AudioCapturerConfiguration::Loopback(_) = self {
22846 } else {
22848 *self = AudioCapturerConfiguration::Loopback(fidl::new_empty!(
22850 LoopbackAudioCapturerConfiguration,
22851 D
22852 ));
22853 }
22854 #[allow(irrefutable_let_patterns)]
22855 if let AudioCapturerConfiguration::Loopback(ref mut val) = self {
22856 fidl::decode!(
22857 LoopbackAudioCapturerConfiguration,
22858 D,
22859 val,
22860 decoder,
22861 _inner_offset,
22862 depth
22863 )?;
22864 } else {
22865 unreachable!()
22866 }
22867 }
22868 2 => {
22869 #[allow(irrefutable_let_patterns)]
22870 if let AudioCapturerConfiguration::Input(_) = self {
22871 } else {
22873 *self = AudioCapturerConfiguration::Input(fidl::new_empty!(
22875 InputAudioCapturerConfiguration,
22876 D
22877 ));
22878 }
22879 #[allow(irrefutable_let_patterns)]
22880 if let AudioCapturerConfiguration::Input(ref mut val) = self {
22881 fidl::decode!(
22882 InputAudioCapturerConfiguration,
22883 D,
22884 val,
22885 decoder,
22886 _inner_offset,
22887 depth
22888 )?;
22889 } else {
22890 unreachable!()
22891 }
22892 }
22893 ordinal => panic!("unexpected ordinal {:?}", ordinal),
22894 }
22895 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22896 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22897 }
22898 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22899 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22900 }
22901 Ok(())
22902 }
22903 }
22904
22905 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormat {
22906 type Borrowed<'a> = &'a Self;
22907 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22908 value
22909 }
22910 }
22911
22912 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormat {
22913 type Owned = Self;
22914
22915 #[inline(always)]
22916 fn inline_align(_context: fidl::encoding::Context) -> usize {
22917 8
22918 }
22919
22920 #[inline(always)]
22921 fn inline_size(_context: fidl::encoding::Context) -> usize {
22922 16
22923 }
22924 }
22925
22926 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioCompressedFormat, D>
22927 for &AudioCompressedFormat
22928 {
22929 #[inline]
22930 unsafe fn encode(
22931 self,
22932 encoder: &mut fidl::encoding::Encoder<'_, D>,
22933 offset: usize,
22934 _depth: fidl::encoding::Depth,
22935 ) -> fidl::Result<()> {
22936 encoder.debug_check_bounds::<AudioCompressedFormat>(offset);
22937 encoder.write_num::<u64>(self.ordinal(), offset);
22938 match self {
22939 AudioCompressedFormat::Aac(ref val) => {
22940 fidl::encoding::encode_in_envelope::<AudioCompressedFormatAac, D>(
22941 <AudioCompressedFormatAac as fidl::encoding::ValueTypeMarker>::borrow(val),
22942 encoder,
22943 offset + 8,
22944 _depth,
22945 )
22946 }
22947 AudioCompressedFormat::Sbc(ref val) => {
22948 fidl::encoding::encode_in_envelope::<AudioCompressedFormatSbc, D>(
22949 <AudioCompressedFormatSbc as fidl::encoding::ValueTypeMarker>::borrow(val),
22950 encoder,
22951 offset + 8,
22952 _depth,
22953 )
22954 }
22955 AudioCompressedFormat::Cvsd(ref val) => {
22956 fidl::encoding::encode_in_envelope::<AudioCompressedFormatCvsd, D>(
22957 <AudioCompressedFormatCvsd as fidl::encoding::ValueTypeMarker>::borrow(val),
22958 encoder,
22959 offset + 8,
22960 _depth,
22961 )
22962 }
22963 AudioCompressedFormat::Lc3(ref val) => {
22964 fidl::encoding::encode_in_envelope::<AudioCompressedFormatLc3, D>(
22965 <AudioCompressedFormatLc3 as fidl::encoding::ValueTypeMarker>::borrow(val),
22966 encoder,
22967 offset + 8,
22968 _depth,
22969 )
22970 }
22971 AudioCompressedFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22972 }
22973 }
22974 }
22975
22976 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCompressedFormat {
22977 #[inline(always)]
22978 fn new_empty() -> Self {
22979 Self::__SourceBreaking { unknown_ordinal: 0 }
22980 }
22981
22982 #[inline]
22983 unsafe fn decode(
22984 &mut self,
22985 decoder: &mut fidl::encoding::Decoder<'_, D>,
22986 offset: usize,
22987 mut depth: fidl::encoding::Depth,
22988 ) -> fidl::Result<()> {
22989 decoder.debug_check_bounds::<Self>(offset);
22990 #[allow(unused_variables)]
22991 let next_out_of_line = decoder.next_out_of_line();
22992 let handles_before = decoder.remaining_handles();
22993 let (ordinal, inlined, num_bytes, num_handles) =
22994 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22995
22996 let member_inline_size = match ordinal {
22997 1 => <AudioCompressedFormatAac as fidl::encoding::TypeMarker>::inline_size(
22998 decoder.context,
22999 ),
23000 2 => <AudioCompressedFormatSbc as fidl::encoding::TypeMarker>::inline_size(
23001 decoder.context,
23002 ),
23003 3 => <AudioCompressedFormatCvsd as fidl::encoding::TypeMarker>::inline_size(
23004 decoder.context,
23005 ),
23006 4 => <AudioCompressedFormatLc3 as fidl::encoding::TypeMarker>::inline_size(
23007 decoder.context,
23008 ),
23009 0 => return Err(fidl::Error::UnknownUnionTag),
23010 _ => num_bytes as usize,
23011 };
23012
23013 if inlined != (member_inline_size <= 4) {
23014 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23015 }
23016 let _inner_offset;
23017 if inlined {
23018 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23019 _inner_offset = offset + 8;
23020 } else {
23021 depth.increment()?;
23022 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23023 }
23024 match ordinal {
23025 1 => {
23026 #[allow(irrefutable_let_patterns)]
23027 if let AudioCompressedFormat::Aac(_) = self {
23028 } else {
23030 *self = AudioCompressedFormat::Aac(fidl::new_empty!(
23032 AudioCompressedFormatAac,
23033 D
23034 ));
23035 }
23036 #[allow(irrefutable_let_patterns)]
23037 if let AudioCompressedFormat::Aac(ref mut val) = self {
23038 fidl::decode!(
23039 AudioCompressedFormatAac,
23040 D,
23041 val,
23042 decoder,
23043 _inner_offset,
23044 depth
23045 )?;
23046 } else {
23047 unreachable!()
23048 }
23049 }
23050 2 => {
23051 #[allow(irrefutable_let_patterns)]
23052 if let AudioCompressedFormat::Sbc(_) = self {
23053 } else {
23055 *self = AudioCompressedFormat::Sbc(fidl::new_empty!(
23057 AudioCompressedFormatSbc,
23058 D
23059 ));
23060 }
23061 #[allow(irrefutable_let_patterns)]
23062 if let AudioCompressedFormat::Sbc(ref mut val) = self {
23063 fidl::decode!(
23064 AudioCompressedFormatSbc,
23065 D,
23066 val,
23067 decoder,
23068 _inner_offset,
23069 depth
23070 )?;
23071 } else {
23072 unreachable!()
23073 }
23074 }
23075 3 => {
23076 #[allow(irrefutable_let_patterns)]
23077 if let AudioCompressedFormat::Cvsd(_) = self {
23078 } else {
23080 *self = AudioCompressedFormat::Cvsd(fidl::new_empty!(
23082 AudioCompressedFormatCvsd,
23083 D
23084 ));
23085 }
23086 #[allow(irrefutable_let_patterns)]
23087 if let AudioCompressedFormat::Cvsd(ref mut val) = self {
23088 fidl::decode!(
23089 AudioCompressedFormatCvsd,
23090 D,
23091 val,
23092 decoder,
23093 _inner_offset,
23094 depth
23095 )?;
23096 } else {
23097 unreachable!()
23098 }
23099 }
23100 4 => {
23101 #[allow(irrefutable_let_patterns)]
23102 if let AudioCompressedFormat::Lc3(_) = self {
23103 } else {
23105 *self = AudioCompressedFormat::Lc3(fidl::new_empty!(
23107 AudioCompressedFormatLc3,
23108 D
23109 ));
23110 }
23111 #[allow(irrefutable_let_patterns)]
23112 if let AudioCompressedFormat::Lc3(ref mut val) = self {
23113 fidl::decode!(
23114 AudioCompressedFormatLc3,
23115 D,
23116 val,
23117 decoder,
23118 _inner_offset,
23119 depth
23120 )?;
23121 } else {
23122 unreachable!()
23123 }
23124 }
23125 #[allow(deprecated)]
23126 ordinal => {
23127 for _ in 0..num_handles {
23128 decoder.drop_next_handle()?;
23129 }
23130 *self = AudioCompressedFormat::__SourceBreaking { unknown_ordinal: ordinal };
23131 }
23132 }
23133 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23134 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23135 }
23136 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23137 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23138 }
23139 Ok(())
23140 }
23141 }
23142
23143 impl fidl::encoding::ValueTypeMarker for AudioConsumerError {
23144 type Borrowed<'a> = &'a Self;
23145 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23146 value
23147 }
23148 }
23149
23150 unsafe impl fidl::encoding::TypeMarker for AudioConsumerError {
23151 type Owned = Self;
23152
23153 #[inline(always)]
23154 fn inline_align(_context: fidl::encoding::Context) -> usize {
23155 8
23156 }
23157
23158 #[inline(always)]
23159 fn inline_size(_context: fidl::encoding::Context) -> usize {
23160 16
23161 }
23162 }
23163
23164 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerError, D>
23165 for &AudioConsumerError
23166 {
23167 #[inline]
23168 unsafe fn encode(
23169 self,
23170 encoder: &mut fidl::encoding::Encoder<'_, D>,
23171 offset: usize,
23172 _depth: fidl::encoding::Depth,
23173 ) -> fidl::Result<()> {
23174 encoder.debug_check_bounds::<AudioConsumerError>(offset);
23175 encoder.write_num::<u64>(self.ordinal(), offset);
23176 match self {
23177 AudioConsumerError::PlaceHolder(ref val) => {
23178 fidl::encoding::encode_in_envelope::<Void, D>(
23179 <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
23180 encoder,
23181 offset + 8,
23182 _depth,
23183 )
23184 }
23185 }
23186 }
23187 }
23188
23189 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerError {
23190 #[inline(always)]
23191 fn new_empty() -> Self {
23192 Self::PlaceHolder(fidl::new_empty!(Void, D))
23193 }
23194
23195 #[inline]
23196 unsafe fn decode(
23197 &mut self,
23198 decoder: &mut fidl::encoding::Decoder<'_, D>,
23199 offset: usize,
23200 mut depth: fidl::encoding::Depth,
23201 ) -> fidl::Result<()> {
23202 decoder.debug_check_bounds::<Self>(offset);
23203 #[allow(unused_variables)]
23204 let next_out_of_line = decoder.next_out_of_line();
23205 let handles_before = decoder.remaining_handles();
23206 let (ordinal, inlined, num_bytes, num_handles) =
23207 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23208
23209 let member_inline_size = match ordinal {
23210 1 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23211 _ => return Err(fidl::Error::UnknownUnionTag),
23212 };
23213
23214 if inlined != (member_inline_size <= 4) {
23215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23216 }
23217 let _inner_offset;
23218 if inlined {
23219 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23220 _inner_offset = offset + 8;
23221 } else {
23222 depth.increment()?;
23223 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23224 }
23225 match ordinal {
23226 1 => {
23227 #[allow(irrefutable_let_patterns)]
23228 if let AudioConsumerError::PlaceHolder(_) = self {
23229 } else {
23231 *self = AudioConsumerError::PlaceHolder(fidl::new_empty!(Void, D));
23233 }
23234 #[allow(irrefutable_let_patterns)]
23235 if let AudioConsumerError::PlaceHolder(ref mut val) = self {
23236 fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
23237 } else {
23238 unreachable!()
23239 }
23240 }
23241 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23242 }
23243 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23244 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23245 }
23246 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23247 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23248 }
23249 Ok(())
23250 }
23251 }
23252
23253 impl fidl::encoding::ValueTypeMarker for AudioFormat {
23254 type Borrowed<'a> = &'a Self;
23255 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23256 value
23257 }
23258 }
23259
23260 unsafe impl fidl::encoding::TypeMarker for AudioFormat {
23261 type Owned = Self;
23262
23263 #[inline(always)]
23264 fn inline_align(_context: fidl::encoding::Context) -> usize {
23265 8
23266 }
23267
23268 #[inline(always)]
23269 fn inline_size(_context: fidl::encoding::Context) -> usize {
23270 16
23271 }
23272 }
23273
23274 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioFormat, D>
23275 for &AudioFormat
23276 {
23277 #[inline]
23278 unsafe fn encode(
23279 self,
23280 encoder: &mut fidl::encoding::Encoder<'_, D>,
23281 offset: usize,
23282 _depth: fidl::encoding::Depth,
23283 ) -> fidl::Result<()> {
23284 encoder.debug_check_bounds::<AudioFormat>(offset);
23285 encoder.write_num::<u64>(self.ordinal(), offset);
23286 match self {
23287 AudioFormat::Compressed(ref val) => {
23288 fidl::encoding::encode_in_envelope::<AudioCompressedFormat, D>(
23289 <AudioCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23290 encoder,
23291 offset + 8,
23292 _depth,
23293 )
23294 }
23295 AudioFormat::Uncompressed(ref val) => {
23296 fidl::encoding::encode_in_envelope::<AudioUncompressedFormat, D>(
23297 <AudioUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23298 encoder,
23299 offset + 8,
23300 _depth,
23301 )
23302 }
23303 }
23304 }
23305 }
23306
23307 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioFormat {
23308 #[inline(always)]
23309 fn new_empty() -> Self {
23310 Self::Compressed(fidl::new_empty!(AudioCompressedFormat, D))
23311 }
23312
23313 #[inline]
23314 unsafe fn decode(
23315 &mut self,
23316 decoder: &mut fidl::encoding::Decoder<'_, D>,
23317 offset: usize,
23318 mut depth: fidl::encoding::Depth,
23319 ) -> fidl::Result<()> {
23320 decoder.debug_check_bounds::<Self>(offset);
23321 #[allow(unused_variables)]
23322 let next_out_of_line = decoder.next_out_of_line();
23323 let handles_before = decoder.remaining_handles();
23324 let (ordinal, inlined, num_bytes, num_handles) =
23325 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23326
23327 let member_inline_size = match ordinal {
23328 1 => <AudioCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23329 decoder.context,
23330 ),
23331 2 => <AudioUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23332 decoder.context,
23333 ),
23334 _ => return Err(fidl::Error::UnknownUnionTag),
23335 };
23336
23337 if inlined != (member_inline_size <= 4) {
23338 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23339 }
23340 let _inner_offset;
23341 if inlined {
23342 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23343 _inner_offset = offset + 8;
23344 } else {
23345 depth.increment()?;
23346 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23347 }
23348 match ordinal {
23349 1 => {
23350 #[allow(irrefutable_let_patterns)]
23351 if let AudioFormat::Compressed(_) = self {
23352 } else {
23354 *self = AudioFormat::Compressed(fidl::new_empty!(AudioCompressedFormat, D));
23356 }
23357 #[allow(irrefutable_let_patterns)]
23358 if let AudioFormat::Compressed(ref mut val) = self {
23359 fidl::decode!(
23360 AudioCompressedFormat,
23361 D,
23362 val,
23363 decoder,
23364 _inner_offset,
23365 depth
23366 )?;
23367 } else {
23368 unreachable!()
23369 }
23370 }
23371 2 => {
23372 #[allow(irrefutable_let_patterns)]
23373 if let AudioFormat::Uncompressed(_) = self {
23374 } else {
23376 *self =
23378 AudioFormat::Uncompressed(fidl::new_empty!(AudioUncompressedFormat, D));
23379 }
23380 #[allow(irrefutable_let_patterns)]
23381 if let AudioFormat::Uncompressed(ref mut val) = self {
23382 fidl::decode!(
23383 AudioUncompressedFormat,
23384 D,
23385 val,
23386 decoder,
23387 _inner_offset,
23388 depth
23389 )?;
23390 } else {
23391 unreachable!()
23392 }
23393 }
23394 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23395 }
23396 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23397 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23398 }
23399 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23400 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23401 }
23402 Ok(())
23403 }
23404 }
23405
23406 impl fidl::encoding::ValueTypeMarker for AudioUncompressedFormat {
23407 type Borrowed<'a> = &'a Self;
23408 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23409 value
23410 }
23411 }
23412
23413 unsafe impl fidl::encoding::TypeMarker for AudioUncompressedFormat {
23414 type Owned = Self;
23415
23416 #[inline(always)]
23417 fn inline_align(_context: fidl::encoding::Context) -> usize {
23418 8
23419 }
23420
23421 #[inline(always)]
23422 fn inline_size(_context: fidl::encoding::Context) -> usize {
23423 16
23424 }
23425 }
23426
23427 unsafe impl<D: fidl::encoding::ResourceDialect>
23428 fidl::encoding::Encode<AudioUncompressedFormat, D> for &AudioUncompressedFormat
23429 {
23430 #[inline]
23431 unsafe fn encode(
23432 self,
23433 encoder: &mut fidl::encoding::Encoder<'_, D>,
23434 offset: usize,
23435 _depth: fidl::encoding::Depth,
23436 ) -> fidl::Result<()> {
23437 encoder.debug_check_bounds::<AudioUncompressedFormat>(offset);
23438 encoder.write_num::<u64>(self.ordinal(), offset);
23439 match self {
23440 AudioUncompressedFormat::Pcm(ref val) => {
23441 fidl::encoding::encode_in_envelope::<PcmFormat, D>(
23442 <PcmFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23443 encoder,
23444 offset + 8,
23445 _depth,
23446 )
23447 }
23448 }
23449 }
23450 }
23451
23452 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
23453 for AudioUncompressedFormat
23454 {
23455 #[inline(always)]
23456 fn new_empty() -> Self {
23457 Self::Pcm(fidl::new_empty!(PcmFormat, D))
23458 }
23459
23460 #[inline]
23461 unsafe fn decode(
23462 &mut self,
23463 decoder: &mut fidl::encoding::Decoder<'_, D>,
23464 offset: usize,
23465 mut depth: fidl::encoding::Depth,
23466 ) -> fidl::Result<()> {
23467 decoder.debug_check_bounds::<Self>(offset);
23468 #[allow(unused_variables)]
23469 let next_out_of_line = decoder.next_out_of_line();
23470 let handles_before = decoder.remaining_handles();
23471 let (ordinal, inlined, num_bytes, num_handles) =
23472 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23473
23474 let member_inline_size = match ordinal {
23475 1 => <PcmFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23476 _ => return Err(fidl::Error::UnknownUnionTag),
23477 };
23478
23479 if inlined != (member_inline_size <= 4) {
23480 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23481 }
23482 let _inner_offset;
23483 if inlined {
23484 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23485 _inner_offset = offset + 8;
23486 } else {
23487 depth.increment()?;
23488 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23489 }
23490 match ordinal {
23491 1 => {
23492 #[allow(irrefutable_let_patterns)]
23493 if let AudioUncompressedFormat::Pcm(_) = self {
23494 } else {
23496 *self = AudioUncompressedFormat::Pcm(fidl::new_empty!(PcmFormat, D));
23498 }
23499 #[allow(irrefutable_let_patterns)]
23500 if let AudioUncompressedFormat::Pcm(ref mut val) = self {
23501 fidl::decode!(PcmFormat, D, val, decoder, _inner_offset, depth)?;
23502 } else {
23503 unreachable!()
23504 }
23505 }
23506 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23507 }
23508 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23509 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23510 }
23511 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23512 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23513 }
23514 Ok(())
23515 }
23516 }
23517
23518 impl fidl::encoding::ValueTypeMarker for CryptoFormat {
23519 type Borrowed<'a> = &'a Self;
23520 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23521 value
23522 }
23523 }
23524
23525 unsafe impl fidl::encoding::TypeMarker for CryptoFormat {
23526 type Owned = Self;
23527
23528 #[inline(always)]
23529 fn inline_align(_context: fidl::encoding::Context) -> usize {
23530 8
23531 }
23532
23533 #[inline(always)]
23534 fn inline_size(_context: fidl::encoding::Context) -> usize {
23535 16
23536 }
23537 }
23538
23539 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CryptoFormat, D>
23540 for &CryptoFormat
23541 {
23542 #[inline]
23543 unsafe fn encode(
23544 self,
23545 encoder: &mut fidl::encoding::Encoder<'_, D>,
23546 offset: usize,
23547 _depth: fidl::encoding::Depth,
23548 ) -> fidl::Result<()> {
23549 encoder.debug_check_bounds::<CryptoFormat>(offset);
23550 encoder.write_num::<u64>(self.ordinal(), offset);
23551 match self {
23552 CryptoFormat::Encrypted(ref val) => {
23553 fidl::encoding::encode_in_envelope::<EncryptedFormat, D>(
23554 <EncryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23555 encoder,
23556 offset + 8,
23557 _depth,
23558 )
23559 }
23560 CryptoFormat::Decrypted(ref val) => {
23561 fidl::encoding::encode_in_envelope::<DecryptedFormat, D>(
23562 <DecryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23563 encoder,
23564 offset + 8,
23565 _depth,
23566 )
23567 }
23568 CryptoFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23569 }
23570 }
23571 }
23572
23573 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CryptoFormat {
23574 #[inline(always)]
23575 fn new_empty() -> Self {
23576 Self::__SourceBreaking { unknown_ordinal: 0 }
23577 }
23578
23579 #[inline]
23580 unsafe fn decode(
23581 &mut self,
23582 decoder: &mut fidl::encoding::Decoder<'_, D>,
23583 offset: usize,
23584 mut depth: fidl::encoding::Depth,
23585 ) -> fidl::Result<()> {
23586 decoder.debug_check_bounds::<Self>(offset);
23587 #[allow(unused_variables)]
23588 let next_out_of_line = decoder.next_out_of_line();
23589 let handles_before = decoder.remaining_handles();
23590 let (ordinal, inlined, num_bytes, num_handles) =
23591 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23592
23593 let member_inline_size = match ordinal {
23594 1 => <EncryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23595 2 => <DecryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23596 0 => return Err(fidl::Error::UnknownUnionTag),
23597 _ => num_bytes as usize,
23598 };
23599
23600 if inlined != (member_inline_size <= 4) {
23601 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23602 }
23603 let _inner_offset;
23604 if inlined {
23605 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23606 _inner_offset = offset + 8;
23607 } else {
23608 depth.increment()?;
23609 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23610 }
23611 match ordinal {
23612 1 => {
23613 #[allow(irrefutable_let_patterns)]
23614 if let CryptoFormat::Encrypted(_) = self {
23615 } else {
23617 *self = CryptoFormat::Encrypted(fidl::new_empty!(EncryptedFormat, D));
23619 }
23620 #[allow(irrefutable_let_patterns)]
23621 if let CryptoFormat::Encrypted(ref mut val) = self {
23622 fidl::decode!(EncryptedFormat, D, val, decoder, _inner_offset, depth)?;
23623 } else {
23624 unreachable!()
23625 }
23626 }
23627 2 => {
23628 #[allow(irrefutable_let_patterns)]
23629 if let CryptoFormat::Decrypted(_) = self {
23630 } else {
23632 *self = CryptoFormat::Decrypted(fidl::new_empty!(DecryptedFormat, D));
23634 }
23635 #[allow(irrefutable_let_patterns)]
23636 if let CryptoFormat::Decrypted(ref mut val) = self {
23637 fidl::decode!(DecryptedFormat, D, val, decoder, _inner_offset, depth)?;
23638 } else {
23639 unreachable!()
23640 }
23641 }
23642 #[allow(deprecated)]
23643 ordinal => {
23644 for _ in 0..num_handles {
23645 decoder.drop_next_handle()?;
23646 }
23647 *self = CryptoFormat::__SourceBreaking { unknown_ordinal: ordinal };
23648 }
23649 }
23650 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23651 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23652 }
23653 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23654 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23655 }
23656 Ok(())
23657 }
23658 }
23659
23660 impl fidl::encoding::ValueTypeMarker for DomainFormat {
23661 type Borrowed<'a> = &'a Self;
23662 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23663 value
23664 }
23665 }
23666
23667 unsafe impl fidl::encoding::TypeMarker for DomainFormat {
23668 type Owned = Self;
23669
23670 #[inline(always)]
23671 fn inline_align(_context: fidl::encoding::Context) -> usize {
23672 8
23673 }
23674
23675 #[inline(always)]
23676 fn inline_size(_context: fidl::encoding::Context) -> usize {
23677 16
23678 }
23679 }
23680
23681 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DomainFormat, D>
23682 for &DomainFormat
23683 {
23684 #[inline]
23685 unsafe fn encode(
23686 self,
23687 encoder: &mut fidl::encoding::Encoder<'_, D>,
23688 offset: usize,
23689 _depth: fidl::encoding::Depth,
23690 ) -> fidl::Result<()> {
23691 encoder.debug_check_bounds::<DomainFormat>(offset);
23692 encoder.write_num::<u64>(self.ordinal(), offset);
23693 match self {
23694 DomainFormat::Audio(ref val) => {
23695 fidl::encoding::encode_in_envelope::<AudioFormat, D>(
23696 <AudioFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23697 encoder,
23698 offset + 8,
23699 _depth,
23700 )
23701 }
23702 DomainFormat::Video(ref val) => {
23703 fidl::encoding::encode_in_envelope::<VideoFormat, D>(
23704 <VideoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23705 encoder,
23706 offset + 8,
23707 _depth,
23708 )
23709 }
23710 DomainFormat::Crypto(ref val) => {
23711 fidl::encoding::encode_in_envelope::<CryptoFormat, D>(
23712 <CryptoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23713 encoder,
23714 offset + 8,
23715 _depth,
23716 )
23717 }
23718 }
23719 }
23720 }
23721
23722 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DomainFormat {
23723 #[inline(always)]
23724 fn new_empty() -> Self {
23725 Self::Audio(fidl::new_empty!(AudioFormat, D))
23726 }
23727
23728 #[inline]
23729 unsafe fn decode(
23730 &mut self,
23731 decoder: &mut fidl::encoding::Decoder<'_, D>,
23732 offset: usize,
23733 mut depth: fidl::encoding::Depth,
23734 ) -> fidl::Result<()> {
23735 decoder.debug_check_bounds::<Self>(offset);
23736 #[allow(unused_variables)]
23737 let next_out_of_line = decoder.next_out_of_line();
23738 let handles_before = decoder.remaining_handles();
23739 let (ordinal, inlined, num_bytes, num_handles) =
23740 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23741
23742 let member_inline_size = match ordinal {
23743 1 => <AudioFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23744 2 => <VideoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23745 3 => <CryptoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23746 _ => return Err(fidl::Error::UnknownUnionTag),
23747 };
23748
23749 if inlined != (member_inline_size <= 4) {
23750 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23751 }
23752 let _inner_offset;
23753 if inlined {
23754 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23755 _inner_offset = offset + 8;
23756 } else {
23757 depth.increment()?;
23758 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23759 }
23760 match ordinal {
23761 1 => {
23762 #[allow(irrefutable_let_patterns)]
23763 if let DomainFormat::Audio(_) = self {
23764 } else {
23766 *self = DomainFormat::Audio(fidl::new_empty!(AudioFormat, D));
23768 }
23769 #[allow(irrefutable_let_patterns)]
23770 if let DomainFormat::Audio(ref mut val) = self {
23771 fidl::decode!(AudioFormat, D, val, decoder, _inner_offset, depth)?;
23772 } else {
23773 unreachable!()
23774 }
23775 }
23776 2 => {
23777 #[allow(irrefutable_let_patterns)]
23778 if let DomainFormat::Video(_) = self {
23779 } else {
23781 *self = DomainFormat::Video(fidl::new_empty!(VideoFormat, D));
23783 }
23784 #[allow(irrefutable_let_patterns)]
23785 if let DomainFormat::Video(ref mut val) = self {
23786 fidl::decode!(VideoFormat, D, val, decoder, _inner_offset, depth)?;
23787 } else {
23788 unreachable!()
23789 }
23790 }
23791 3 => {
23792 #[allow(irrefutable_let_patterns)]
23793 if let DomainFormat::Crypto(_) = self {
23794 } else {
23796 *self = DomainFormat::Crypto(fidl::new_empty!(CryptoFormat, D));
23798 }
23799 #[allow(irrefutable_let_patterns)]
23800 if let DomainFormat::Crypto(ref mut val) = self {
23801 fidl::decode!(CryptoFormat, D, val, decoder, _inner_offset, depth)?;
23802 } else {
23803 unreachable!()
23804 }
23805 }
23806 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23807 }
23808 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23809 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23810 }
23811 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23812 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23813 }
23814 Ok(())
23815 }
23816 }
23817
23818 impl fidl::encoding::ValueTypeMarker for EncoderSettings {
23819 type Borrowed<'a> = &'a Self;
23820 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23821 value
23822 }
23823 }
23824
23825 unsafe impl fidl::encoding::TypeMarker for EncoderSettings {
23826 type Owned = Self;
23827
23828 #[inline(always)]
23829 fn inline_align(_context: fidl::encoding::Context) -> usize {
23830 8
23831 }
23832
23833 #[inline(always)]
23834 fn inline_size(_context: fidl::encoding::Context) -> usize {
23835 16
23836 }
23837 }
23838
23839 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncoderSettings, D>
23840 for &EncoderSettings
23841 {
23842 #[inline]
23843 unsafe fn encode(
23844 self,
23845 encoder: &mut fidl::encoding::Encoder<'_, D>,
23846 offset: usize,
23847 _depth: fidl::encoding::Depth,
23848 ) -> fidl::Result<()> {
23849 encoder.debug_check_bounds::<EncoderSettings>(offset);
23850 encoder.write_num::<u64>(self.ordinal(), offset);
23851 match self {
23852 EncoderSettings::Sbc(ref val) => {
23853 fidl::encoding::encode_in_envelope::<SbcEncoderSettings, D>(
23854 <SbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23855 encoder,
23856 offset + 8,
23857 _depth,
23858 )
23859 }
23860 EncoderSettings::Aac(ref val) => {
23861 fidl::encoding::encode_in_envelope::<AacEncoderSettings, D>(
23862 <AacEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23863 encoder,
23864 offset + 8,
23865 _depth,
23866 )
23867 }
23868 EncoderSettings::H264(ref val) => {
23869 fidl::encoding::encode_in_envelope::<H264EncoderSettings, D>(
23870 <H264EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23871 encoder,
23872 offset + 8,
23873 _depth,
23874 )
23875 }
23876 EncoderSettings::Hevc(ref val) => {
23877 fidl::encoding::encode_in_envelope::<HevcEncoderSettings, D>(
23878 <HevcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23879 encoder,
23880 offset + 8,
23881 _depth,
23882 )
23883 }
23884 EncoderSettings::Cvsd(ref val) => {
23885 fidl::encoding::encode_in_envelope::<CvsdEncoderSettings, D>(
23886 <CvsdEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23887 encoder,
23888 offset + 8,
23889 _depth,
23890 )
23891 }
23892 EncoderSettings::Lc3(ref val) => {
23893 fidl::encoding::encode_in_envelope::<Lc3EncoderSettings, D>(
23894 <Lc3EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23895 encoder,
23896 offset + 8,
23897 _depth,
23898 )
23899 }
23900 EncoderSettings::Msbc(ref val) => {
23901 fidl::encoding::encode_in_envelope::<MSbcEncoderSettings, D>(
23902 <MSbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23903 encoder,
23904 offset + 8,
23905 _depth,
23906 )
23907 }
23908 EncoderSettings::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23909 }
23910 }
23911 }
23912
23913 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncoderSettings {
23914 #[inline(always)]
23915 fn new_empty() -> Self {
23916 Self::__SourceBreaking { unknown_ordinal: 0 }
23917 }
23918
23919 #[inline]
23920 unsafe fn decode(
23921 &mut self,
23922 decoder: &mut fidl::encoding::Decoder<'_, D>,
23923 offset: usize,
23924 mut depth: fidl::encoding::Depth,
23925 ) -> fidl::Result<()> {
23926 decoder.debug_check_bounds::<Self>(offset);
23927 #[allow(unused_variables)]
23928 let next_out_of_line = decoder.next_out_of_line();
23929 let handles_before = decoder.remaining_handles();
23930 let (ordinal, inlined, num_bytes, num_handles) =
23931 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23932
23933 let member_inline_size = match ordinal {
23934 1 => {
23935 <SbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23936 }
23937 2 => {
23938 <AacEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23939 }
23940 3 => <H264EncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23941 decoder.context,
23942 ),
23943 4 => <HevcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23944 decoder.context,
23945 ),
23946 5 => <CvsdEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23947 decoder.context,
23948 ),
23949 6 => {
23950 <Lc3EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23951 }
23952 7 => <MSbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23953 decoder.context,
23954 ),
23955 0 => return Err(fidl::Error::UnknownUnionTag),
23956 _ => num_bytes as usize,
23957 };
23958
23959 if inlined != (member_inline_size <= 4) {
23960 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23961 }
23962 let _inner_offset;
23963 if inlined {
23964 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23965 _inner_offset = offset + 8;
23966 } else {
23967 depth.increment()?;
23968 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23969 }
23970 match ordinal {
23971 1 => {
23972 #[allow(irrefutable_let_patterns)]
23973 if let EncoderSettings::Sbc(_) = self {
23974 } else {
23976 *self = EncoderSettings::Sbc(fidl::new_empty!(SbcEncoderSettings, D));
23978 }
23979 #[allow(irrefutable_let_patterns)]
23980 if let EncoderSettings::Sbc(ref mut val) = self {
23981 fidl::decode!(SbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23982 } else {
23983 unreachable!()
23984 }
23985 }
23986 2 => {
23987 #[allow(irrefutable_let_patterns)]
23988 if let EncoderSettings::Aac(_) = self {
23989 } else {
23991 *self = EncoderSettings::Aac(fidl::new_empty!(AacEncoderSettings, D));
23993 }
23994 #[allow(irrefutable_let_patterns)]
23995 if let EncoderSettings::Aac(ref mut val) = self {
23996 fidl::decode!(AacEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23997 } else {
23998 unreachable!()
23999 }
24000 }
24001 3 => {
24002 #[allow(irrefutable_let_patterns)]
24003 if let EncoderSettings::H264(_) = self {
24004 } else {
24006 *self = EncoderSettings::H264(fidl::new_empty!(H264EncoderSettings, D));
24008 }
24009 #[allow(irrefutable_let_patterns)]
24010 if let EncoderSettings::H264(ref mut val) = self {
24011 fidl::decode!(H264EncoderSettings, D, val, decoder, _inner_offset, depth)?;
24012 } else {
24013 unreachable!()
24014 }
24015 }
24016 4 => {
24017 #[allow(irrefutable_let_patterns)]
24018 if let EncoderSettings::Hevc(_) = self {
24019 } else {
24021 *self = EncoderSettings::Hevc(fidl::new_empty!(HevcEncoderSettings, D));
24023 }
24024 #[allow(irrefutable_let_patterns)]
24025 if let EncoderSettings::Hevc(ref mut val) = self {
24026 fidl::decode!(HevcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24027 } else {
24028 unreachable!()
24029 }
24030 }
24031 5 => {
24032 #[allow(irrefutable_let_patterns)]
24033 if let EncoderSettings::Cvsd(_) = self {
24034 } else {
24036 *self = EncoderSettings::Cvsd(fidl::new_empty!(CvsdEncoderSettings, D));
24038 }
24039 #[allow(irrefutable_let_patterns)]
24040 if let EncoderSettings::Cvsd(ref mut val) = self {
24041 fidl::decode!(CvsdEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24042 } else {
24043 unreachable!()
24044 }
24045 }
24046 6 => {
24047 #[allow(irrefutable_let_patterns)]
24048 if let EncoderSettings::Lc3(_) = self {
24049 } else {
24051 *self = EncoderSettings::Lc3(fidl::new_empty!(Lc3EncoderSettings, D));
24053 }
24054 #[allow(irrefutable_let_patterns)]
24055 if let EncoderSettings::Lc3(ref mut val) = self {
24056 fidl::decode!(Lc3EncoderSettings, D, val, decoder, _inner_offset, depth)?;
24057 } else {
24058 unreachable!()
24059 }
24060 }
24061 7 => {
24062 #[allow(irrefutable_let_patterns)]
24063 if let EncoderSettings::Msbc(_) = self {
24064 } else {
24066 *self = EncoderSettings::Msbc(fidl::new_empty!(MSbcEncoderSettings, D));
24068 }
24069 #[allow(irrefutable_let_patterns)]
24070 if let EncoderSettings::Msbc(ref mut val) = self {
24071 fidl::decode!(MSbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24072 } else {
24073 unreachable!()
24074 }
24075 }
24076 #[allow(deprecated)]
24077 ordinal => {
24078 for _ in 0..num_handles {
24079 decoder.drop_next_handle()?;
24080 }
24081 *self = EncoderSettings::__SourceBreaking { unknown_ordinal: ordinal };
24082 }
24083 }
24084 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24085 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24086 }
24087 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24088 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24089 }
24090 Ok(())
24091 }
24092 }
24093
24094 impl fidl::encoding::ValueTypeMarker for MediumSpecificStreamType {
24095 type Borrowed<'a> = &'a Self;
24096 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24097 value
24098 }
24099 }
24100
24101 unsafe impl fidl::encoding::TypeMarker for MediumSpecificStreamType {
24102 type Owned = Self;
24103
24104 #[inline(always)]
24105 fn inline_align(_context: fidl::encoding::Context) -> usize {
24106 8
24107 }
24108
24109 #[inline(always)]
24110 fn inline_size(_context: fidl::encoding::Context) -> usize {
24111 16
24112 }
24113 }
24114
24115 unsafe impl<D: fidl::encoding::ResourceDialect>
24116 fidl::encoding::Encode<MediumSpecificStreamType, D> for &MediumSpecificStreamType
24117 {
24118 #[inline]
24119 unsafe fn encode(
24120 self,
24121 encoder: &mut fidl::encoding::Encoder<'_, D>,
24122 offset: usize,
24123 _depth: fidl::encoding::Depth,
24124 ) -> fidl::Result<()> {
24125 encoder.debug_check_bounds::<MediumSpecificStreamType>(offset);
24126 encoder.write_num::<u64>(self.ordinal(), offset);
24127 match self {
24128 MediumSpecificStreamType::Audio(ref val) => {
24129 fidl::encoding::encode_in_envelope::<AudioStreamType, D>(
24130 <AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24131 encoder,
24132 offset + 8,
24133 _depth,
24134 )
24135 }
24136 MediumSpecificStreamType::Video(ref val) => {
24137 fidl::encoding::encode_in_envelope::<VideoStreamType, D>(
24138 <VideoStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24139 encoder,
24140 offset + 8,
24141 _depth,
24142 )
24143 }
24144 MediumSpecificStreamType::Text(ref val) => {
24145 fidl::encoding::encode_in_envelope::<TextStreamType, D>(
24146 <TextStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24147 encoder,
24148 offset + 8,
24149 _depth,
24150 )
24151 }
24152 MediumSpecificStreamType::Subpicture(ref val) => {
24153 fidl::encoding::encode_in_envelope::<SubpictureStreamType, D>(
24154 <SubpictureStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24155 encoder,
24156 offset + 8,
24157 _depth,
24158 )
24159 }
24160 }
24161 }
24162 }
24163
24164 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
24165 for MediumSpecificStreamType
24166 {
24167 #[inline(always)]
24168 fn new_empty() -> Self {
24169 Self::Audio(fidl::new_empty!(AudioStreamType, D))
24170 }
24171
24172 #[inline]
24173 unsafe fn decode(
24174 &mut self,
24175 decoder: &mut fidl::encoding::Decoder<'_, D>,
24176 offset: usize,
24177 mut depth: fidl::encoding::Depth,
24178 ) -> fidl::Result<()> {
24179 decoder.debug_check_bounds::<Self>(offset);
24180 #[allow(unused_variables)]
24181 let next_out_of_line = decoder.next_out_of_line();
24182 let handles_before = decoder.remaining_handles();
24183 let (ordinal, inlined, num_bytes, num_handles) =
24184 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24185
24186 let member_inline_size = match ordinal {
24187 1 => <AudioStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24188 2 => <VideoStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24189 3 => <TextStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24190 4 => <SubpictureStreamType as fidl::encoding::TypeMarker>::inline_size(
24191 decoder.context,
24192 ),
24193 _ => return Err(fidl::Error::UnknownUnionTag),
24194 };
24195
24196 if inlined != (member_inline_size <= 4) {
24197 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24198 }
24199 let _inner_offset;
24200 if inlined {
24201 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24202 _inner_offset = offset + 8;
24203 } else {
24204 depth.increment()?;
24205 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24206 }
24207 match ordinal {
24208 1 => {
24209 #[allow(irrefutable_let_patterns)]
24210 if let MediumSpecificStreamType::Audio(_) = self {
24211 } else {
24213 *self =
24215 MediumSpecificStreamType::Audio(fidl::new_empty!(AudioStreamType, D));
24216 }
24217 #[allow(irrefutable_let_patterns)]
24218 if let MediumSpecificStreamType::Audio(ref mut val) = self {
24219 fidl::decode!(AudioStreamType, D, val, decoder, _inner_offset, depth)?;
24220 } else {
24221 unreachable!()
24222 }
24223 }
24224 2 => {
24225 #[allow(irrefutable_let_patterns)]
24226 if let MediumSpecificStreamType::Video(_) = self {
24227 } else {
24229 *self =
24231 MediumSpecificStreamType::Video(fidl::new_empty!(VideoStreamType, D));
24232 }
24233 #[allow(irrefutable_let_patterns)]
24234 if let MediumSpecificStreamType::Video(ref mut val) = self {
24235 fidl::decode!(VideoStreamType, D, val, decoder, _inner_offset, depth)?;
24236 } else {
24237 unreachable!()
24238 }
24239 }
24240 3 => {
24241 #[allow(irrefutable_let_patterns)]
24242 if let MediumSpecificStreamType::Text(_) = self {
24243 } else {
24245 *self = MediumSpecificStreamType::Text(fidl::new_empty!(TextStreamType, D));
24247 }
24248 #[allow(irrefutable_let_patterns)]
24249 if let MediumSpecificStreamType::Text(ref mut val) = self {
24250 fidl::decode!(TextStreamType, D, val, decoder, _inner_offset, depth)?;
24251 } else {
24252 unreachable!()
24253 }
24254 }
24255 4 => {
24256 #[allow(irrefutable_let_patterns)]
24257 if let MediumSpecificStreamType::Subpicture(_) = self {
24258 } else {
24260 *self = MediumSpecificStreamType::Subpicture(fidl::new_empty!(
24262 SubpictureStreamType,
24263 D
24264 ));
24265 }
24266 #[allow(irrefutable_let_patterns)]
24267 if let MediumSpecificStreamType::Subpicture(ref mut val) = self {
24268 fidl::decode!(SubpictureStreamType, D, val, decoder, _inner_offset, depth)?;
24269 } else {
24270 unreachable!()
24271 }
24272 }
24273 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24274 }
24275 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24276 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24277 }
24278 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24279 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24280 }
24281 Ok(())
24282 }
24283 }
24284
24285 impl fidl::encoding::ValueTypeMarker for Usage {
24286 type Borrowed<'a> = &'a Self;
24287 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24288 value
24289 }
24290 }
24291
24292 unsafe impl fidl::encoding::TypeMarker for Usage {
24293 type Owned = Self;
24294
24295 #[inline(always)]
24296 fn inline_align(_context: fidl::encoding::Context) -> usize {
24297 8
24298 }
24299
24300 #[inline(always)]
24301 fn inline_size(_context: fidl::encoding::Context) -> usize {
24302 16
24303 }
24304 }
24305
24306 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage, D> for &Usage {
24307 #[inline]
24308 unsafe fn encode(
24309 self,
24310 encoder: &mut fidl::encoding::Encoder<'_, D>,
24311 offset: usize,
24312 _depth: fidl::encoding::Depth,
24313 ) -> fidl::Result<()> {
24314 encoder.debug_check_bounds::<Usage>(offset);
24315 encoder.write_num::<u64>(self.ordinal(), offset);
24316 match self {
24317 Usage::RenderUsage(ref val) => {
24318 fidl::encoding::encode_in_envelope::<AudioRenderUsage, D>(
24319 <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24320 encoder,
24321 offset + 8,
24322 _depth,
24323 )
24324 }
24325 Usage::CaptureUsage(ref val) => {
24326 fidl::encoding::encode_in_envelope::<AudioCaptureUsage, D>(
24327 <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24328 encoder,
24329 offset + 8,
24330 _depth,
24331 )
24332 }
24333 }
24334 }
24335 }
24336
24337 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage {
24338 #[inline(always)]
24339 fn new_empty() -> Self {
24340 Self::RenderUsage(fidl::new_empty!(AudioRenderUsage, D))
24341 }
24342
24343 #[inline]
24344 unsafe fn decode(
24345 &mut self,
24346 decoder: &mut fidl::encoding::Decoder<'_, D>,
24347 offset: usize,
24348 mut depth: fidl::encoding::Depth,
24349 ) -> fidl::Result<()> {
24350 decoder.debug_check_bounds::<Self>(offset);
24351 #[allow(unused_variables)]
24352 let next_out_of_line = decoder.next_out_of_line();
24353 let handles_before = decoder.remaining_handles();
24354 let (ordinal, inlined, num_bytes, num_handles) =
24355 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24356
24357 let member_inline_size = match ordinal {
24358 1 => <AudioRenderUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24359 2 => {
24360 <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24361 }
24362 _ => return Err(fidl::Error::UnknownUnionTag),
24363 };
24364
24365 if inlined != (member_inline_size <= 4) {
24366 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24367 }
24368 let _inner_offset;
24369 if inlined {
24370 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24371 _inner_offset = offset + 8;
24372 } else {
24373 depth.increment()?;
24374 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24375 }
24376 match ordinal {
24377 1 => {
24378 #[allow(irrefutable_let_patterns)]
24379 if let Usage::RenderUsage(_) = self {
24380 } else {
24382 *self = Usage::RenderUsage(fidl::new_empty!(AudioRenderUsage, D));
24384 }
24385 #[allow(irrefutable_let_patterns)]
24386 if let Usage::RenderUsage(ref mut val) = self {
24387 fidl::decode!(AudioRenderUsage, D, val, decoder, _inner_offset, depth)?;
24388 } else {
24389 unreachable!()
24390 }
24391 }
24392 2 => {
24393 #[allow(irrefutable_let_patterns)]
24394 if let Usage::CaptureUsage(_) = self {
24395 } else {
24397 *self = Usage::CaptureUsage(fidl::new_empty!(AudioCaptureUsage, D));
24399 }
24400 #[allow(irrefutable_let_patterns)]
24401 if let Usage::CaptureUsage(ref mut val) = self {
24402 fidl::decode!(AudioCaptureUsage, D, val, decoder, _inner_offset, depth)?;
24403 } else {
24404 unreachable!()
24405 }
24406 }
24407 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24408 }
24409 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24410 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24411 }
24412 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24413 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24414 }
24415 Ok(())
24416 }
24417 }
24418
24419 impl fidl::encoding::ValueTypeMarker for Usage2 {
24420 type Borrowed<'a> = &'a Self;
24421 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24422 value
24423 }
24424 }
24425
24426 unsafe impl fidl::encoding::TypeMarker for Usage2 {
24427 type Owned = Self;
24428
24429 #[inline(always)]
24430 fn inline_align(_context: fidl::encoding::Context) -> usize {
24431 8
24432 }
24433
24434 #[inline(always)]
24435 fn inline_size(_context: fidl::encoding::Context) -> usize {
24436 16
24437 }
24438 }
24439
24440 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage2, D> for &Usage2 {
24441 #[inline]
24442 unsafe fn encode(
24443 self,
24444 encoder: &mut fidl::encoding::Encoder<'_, D>,
24445 offset: usize,
24446 _depth: fidl::encoding::Depth,
24447 ) -> fidl::Result<()> {
24448 encoder.debug_check_bounds::<Usage2>(offset);
24449 encoder.write_num::<u64>(self.ordinal(), offset);
24450 match self {
24451 Usage2::RenderUsage(ref val) => {
24452 fidl::encoding::encode_in_envelope::<AudioRenderUsage2, D>(
24453 <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24454 encoder,
24455 offset + 8,
24456 _depth,
24457 )
24458 }
24459 Usage2::CaptureUsage(ref val) => {
24460 fidl::encoding::encode_in_envelope::<AudioCaptureUsage2, D>(
24461 <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24462 encoder,
24463 offset + 8,
24464 _depth,
24465 )
24466 }
24467 Usage2::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24468 }
24469 }
24470 }
24471
24472 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage2 {
24473 #[inline(always)]
24474 fn new_empty() -> Self {
24475 Self::__SourceBreaking { unknown_ordinal: 0 }
24476 }
24477
24478 #[inline]
24479 unsafe fn decode(
24480 &mut self,
24481 decoder: &mut fidl::encoding::Decoder<'_, D>,
24482 offset: usize,
24483 mut depth: fidl::encoding::Depth,
24484 ) -> fidl::Result<()> {
24485 decoder.debug_check_bounds::<Self>(offset);
24486 #[allow(unused_variables)]
24487 let next_out_of_line = decoder.next_out_of_line();
24488 let handles_before = decoder.remaining_handles();
24489 let (ordinal, inlined, num_bytes, num_handles) =
24490 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24491
24492 let member_inline_size = match ordinal {
24493 1 => {
24494 <AudioRenderUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24495 }
24496 2 => {
24497 <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24498 }
24499 0 => return Err(fidl::Error::UnknownUnionTag),
24500 _ => num_bytes as usize,
24501 };
24502
24503 if inlined != (member_inline_size <= 4) {
24504 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24505 }
24506 let _inner_offset;
24507 if inlined {
24508 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24509 _inner_offset = offset + 8;
24510 } else {
24511 depth.increment()?;
24512 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24513 }
24514 match ordinal {
24515 1 => {
24516 #[allow(irrefutable_let_patterns)]
24517 if let Usage2::RenderUsage(_) = self {
24518 } else {
24520 *self = Usage2::RenderUsage(fidl::new_empty!(AudioRenderUsage2, D));
24522 }
24523 #[allow(irrefutable_let_patterns)]
24524 if let Usage2::RenderUsage(ref mut val) = self {
24525 fidl::decode!(AudioRenderUsage2, D, val, decoder, _inner_offset, depth)?;
24526 } else {
24527 unreachable!()
24528 }
24529 }
24530 2 => {
24531 #[allow(irrefutable_let_patterns)]
24532 if let Usage2::CaptureUsage(_) = self {
24533 } else {
24535 *self = Usage2::CaptureUsage(fidl::new_empty!(AudioCaptureUsage2, D));
24537 }
24538 #[allow(irrefutable_let_patterns)]
24539 if let Usage2::CaptureUsage(ref mut val) = self {
24540 fidl::decode!(AudioCaptureUsage2, D, val, decoder, _inner_offset, depth)?;
24541 } else {
24542 unreachable!()
24543 }
24544 }
24545 #[allow(deprecated)]
24546 ordinal => {
24547 for _ in 0..num_handles {
24548 decoder.drop_next_handle()?;
24549 }
24550 *self = Usage2::__SourceBreaking { unknown_ordinal: ordinal };
24551 }
24552 }
24553 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24554 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24555 }
24556 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24557 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24558 }
24559 Ok(())
24560 }
24561 }
24562
24563 impl fidl::encoding::ValueTypeMarker for UsageState {
24564 type Borrowed<'a> = &'a Self;
24565 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24566 value
24567 }
24568 }
24569
24570 unsafe impl fidl::encoding::TypeMarker for UsageState {
24571 type Owned = Self;
24572
24573 #[inline(always)]
24574 fn inline_align(_context: fidl::encoding::Context) -> usize {
24575 8
24576 }
24577
24578 #[inline(always)]
24579 fn inline_size(_context: fidl::encoding::Context) -> usize {
24580 16
24581 }
24582 }
24583
24584 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageState, D>
24585 for &UsageState
24586 {
24587 #[inline]
24588 unsafe fn encode(
24589 self,
24590 encoder: &mut fidl::encoding::Encoder<'_, D>,
24591 offset: usize,
24592 _depth: fidl::encoding::Depth,
24593 ) -> fidl::Result<()> {
24594 encoder.debug_check_bounds::<UsageState>(offset);
24595 encoder.write_num::<u64>(self.ordinal(), offset);
24596 match self {
24597 UsageState::Unadjusted(ref val) => {
24598 fidl::encoding::encode_in_envelope::<UsageStateUnadjusted, D>(
24599 <UsageStateUnadjusted as fidl::encoding::ValueTypeMarker>::borrow(val),
24600 encoder,
24601 offset + 8,
24602 _depth,
24603 )
24604 }
24605 UsageState::Ducked(ref val) => {
24606 fidl::encoding::encode_in_envelope::<UsageStateDucked, D>(
24607 <UsageStateDucked as fidl::encoding::ValueTypeMarker>::borrow(val),
24608 encoder,
24609 offset + 8,
24610 _depth,
24611 )
24612 }
24613 UsageState::Muted(ref val) => {
24614 fidl::encoding::encode_in_envelope::<UsageStateMuted, D>(
24615 <UsageStateMuted as fidl::encoding::ValueTypeMarker>::borrow(val),
24616 encoder,
24617 offset + 8,
24618 _depth,
24619 )
24620 }
24621 UsageState::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24622 }
24623 }
24624 }
24625
24626 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageState {
24627 #[inline(always)]
24628 fn new_empty() -> Self {
24629 Self::__SourceBreaking { unknown_ordinal: 0 }
24630 }
24631
24632 #[inline]
24633 unsafe fn decode(
24634 &mut self,
24635 decoder: &mut fidl::encoding::Decoder<'_, D>,
24636 offset: usize,
24637 mut depth: fidl::encoding::Depth,
24638 ) -> fidl::Result<()> {
24639 decoder.debug_check_bounds::<Self>(offset);
24640 #[allow(unused_variables)]
24641 let next_out_of_line = decoder.next_out_of_line();
24642 let handles_before = decoder.remaining_handles();
24643 let (ordinal, inlined, num_bytes, num_handles) =
24644 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24645
24646 let member_inline_size = match ordinal {
24647 1 => <UsageStateUnadjusted as fidl::encoding::TypeMarker>::inline_size(
24648 decoder.context,
24649 ),
24650 2 => <UsageStateDucked as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24651 3 => <UsageStateMuted as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24652 0 => return Err(fidl::Error::UnknownUnionTag),
24653 _ => num_bytes as usize,
24654 };
24655
24656 if inlined != (member_inline_size <= 4) {
24657 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24658 }
24659 let _inner_offset;
24660 if inlined {
24661 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24662 _inner_offset = offset + 8;
24663 } else {
24664 depth.increment()?;
24665 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24666 }
24667 match ordinal {
24668 1 => {
24669 #[allow(irrefutable_let_patterns)]
24670 if let UsageState::Unadjusted(_) = self {
24671 } else {
24673 *self = UsageState::Unadjusted(fidl::new_empty!(UsageStateUnadjusted, D));
24675 }
24676 #[allow(irrefutable_let_patterns)]
24677 if let UsageState::Unadjusted(ref mut val) = self {
24678 fidl::decode!(UsageStateUnadjusted, D, val, decoder, _inner_offset, depth)?;
24679 } else {
24680 unreachable!()
24681 }
24682 }
24683 2 => {
24684 #[allow(irrefutable_let_patterns)]
24685 if let UsageState::Ducked(_) = self {
24686 } else {
24688 *self = UsageState::Ducked(fidl::new_empty!(UsageStateDucked, D));
24690 }
24691 #[allow(irrefutable_let_patterns)]
24692 if let UsageState::Ducked(ref mut val) = self {
24693 fidl::decode!(UsageStateDucked, D, val, decoder, _inner_offset, depth)?;
24694 } else {
24695 unreachable!()
24696 }
24697 }
24698 3 => {
24699 #[allow(irrefutable_let_patterns)]
24700 if let UsageState::Muted(_) = self {
24701 } else {
24703 *self = UsageState::Muted(fidl::new_empty!(UsageStateMuted, D));
24705 }
24706 #[allow(irrefutable_let_patterns)]
24707 if let UsageState::Muted(ref mut val) = self {
24708 fidl::decode!(UsageStateMuted, D, val, decoder, _inner_offset, depth)?;
24709 } else {
24710 unreachable!()
24711 }
24712 }
24713 #[allow(deprecated)]
24714 ordinal => {
24715 for _ in 0..num_handles {
24716 decoder.drop_next_handle()?;
24717 }
24718 *self = UsageState::__SourceBreaking { unknown_ordinal: ordinal };
24719 }
24720 }
24721 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24722 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24723 }
24724 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24725 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24726 }
24727 Ok(())
24728 }
24729 }
24730
24731 impl fidl::encoding::ValueTypeMarker for Value {
24732 type Borrowed<'a> = &'a Self;
24733 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24734 value
24735 }
24736 }
24737
24738 unsafe impl fidl::encoding::TypeMarker for Value {
24739 type Owned = Self;
24740
24741 #[inline(always)]
24742 fn inline_align(_context: fidl::encoding::Context) -> usize {
24743 8
24744 }
24745
24746 #[inline(always)]
24747 fn inline_size(_context: fidl::encoding::Context) -> usize {
24748 16
24749 }
24750 }
24751
24752 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Value, D> for &Value {
24753 #[inline]
24754 unsafe fn encode(
24755 self,
24756 encoder: &mut fidl::encoding::Encoder<'_, D>,
24757 offset: usize,
24758 _depth: fidl::encoding::Depth,
24759 ) -> fidl::Result<()> {
24760 encoder.debug_check_bounds::<Value>(offset);
24761 encoder.write_num::<u64>(self.ordinal(), offset);
24762 match self {
24763 Value::BoolValue(ref val) => {
24764 fidl::encoding::encode_in_envelope::<bool, D>(
24765 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
24766 encoder, offset + 8, _depth
24767 )
24768 }
24769 Value::Uint64Value(ref val) => {
24770 fidl::encoding::encode_in_envelope::<u64, D>(
24771 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24772 encoder, offset + 8, _depth
24773 )
24774 }
24775 Value::Int64Value(ref val) => {
24776 fidl::encoding::encode_in_envelope::<i64, D>(
24777 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24778 encoder, offset + 8, _depth
24779 )
24780 }
24781 Value::StringValue(ref val) => {
24782 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, D>(
24783 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
24784 encoder, offset + 8, _depth
24785 )
24786 }
24787 Value::BytesValue(ref val) => {
24788 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
24789 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
24790 encoder, offset + 8, _depth
24791 )
24792 }
24793 }
24794 }
24795 }
24796
24797 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Value {
24798 #[inline(always)]
24799 fn new_empty() -> Self {
24800 Self::BoolValue(fidl::new_empty!(bool, D))
24801 }
24802
24803 #[inline]
24804 unsafe fn decode(
24805 &mut self,
24806 decoder: &mut fidl::encoding::Decoder<'_, D>,
24807 offset: usize,
24808 mut depth: fidl::encoding::Depth,
24809 ) -> fidl::Result<()> {
24810 decoder.debug_check_bounds::<Self>(offset);
24811 #[allow(unused_variables)]
24812 let next_out_of_line = decoder.next_out_of_line();
24813 let handles_before = decoder.remaining_handles();
24814 let (ordinal, inlined, num_bytes, num_handles) =
24815 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24816
24817 let member_inline_size = match ordinal {
24818 1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24819 2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24820 3 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24821 4 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
24822 decoder.context,
24823 ),
24824 5 => {
24825 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
24826 decoder.context,
24827 )
24828 }
24829 _ => return Err(fidl::Error::UnknownUnionTag),
24830 };
24831
24832 if inlined != (member_inline_size <= 4) {
24833 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24834 }
24835 let _inner_offset;
24836 if inlined {
24837 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24838 _inner_offset = offset + 8;
24839 } else {
24840 depth.increment()?;
24841 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24842 }
24843 match ordinal {
24844 1 => {
24845 #[allow(irrefutable_let_patterns)]
24846 if let Value::BoolValue(_) = self {
24847 } else {
24849 *self = Value::BoolValue(fidl::new_empty!(bool, D));
24851 }
24852 #[allow(irrefutable_let_patterns)]
24853 if let Value::BoolValue(ref mut val) = self {
24854 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
24855 } else {
24856 unreachable!()
24857 }
24858 }
24859 2 => {
24860 #[allow(irrefutable_let_patterns)]
24861 if let Value::Uint64Value(_) = self {
24862 } else {
24864 *self = Value::Uint64Value(fidl::new_empty!(u64, D));
24866 }
24867 #[allow(irrefutable_let_patterns)]
24868 if let Value::Uint64Value(ref mut val) = self {
24869 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
24870 } else {
24871 unreachable!()
24872 }
24873 }
24874 3 => {
24875 #[allow(irrefutable_let_patterns)]
24876 if let Value::Int64Value(_) = self {
24877 } else {
24879 *self = Value::Int64Value(fidl::new_empty!(i64, D));
24881 }
24882 #[allow(irrefutable_let_patterns)]
24883 if let Value::Int64Value(ref mut val) = self {
24884 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
24885 } else {
24886 unreachable!()
24887 }
24888 }
24889 4 => {
24890 #[allow(irrefutable_let_patterns)]
24891 if let Value::StringValue(_) = self {
24892 } else {
24894 *self = Value::StringValue(fidl::new_empty!(
24896 fidl::encoding::UnboundedString,
24897 D
24898 ));
24899 }
24900 #[allow(irrefutable_let_patterns)]
24901 if let Value::StringValue(ref mut val) = self {
24902 fidl::decode!(
24903 fidl::encoding::UnboundedString,
24904 D,
24905 val,
24906 decoder,
24907 _inner_offset,
24908 depth
24909 )?;
24910 } else {
24911 unreachable!()
24912 }
24913 }
24914 5 => {
24915 #[allow(irrefutable_let_patterns)]
24916 if let Value::BytesValue(_) = self {
24917 } else {
24919 *self = Value::BytesValue(fidl::new_empty!(
24921 fidl::encoding::UnboundedVector<u8>,
24922 D
24923 ));
24924 }
24925 #[allow(irrefutable_let_patterns)]
24926 if let Value::BytesValue(ref mut val) = self {
24927 fidl::decode!(
24928 fidl::encoding::UnboundedVector<u8>,
24929 D,
24930 val,
24931 decoder,
24932 _inner_offset,
24933 depth
24934 )?;
24935 } else {
24936 unreachable!()
24937 }
24938 }
24939 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24940 }
24941 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24943 }
24944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24946 }
24947 Ok(())
24948 }
24949 }
24950
24951 impl fidl::encoding::ValueTypeMarker for VideoCompressedFormat {
24952 type Borrowed<'a> = &'a Self;
24953 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24954 value
24955 }
24956 }
24957
24958 unsafe impl fidl::encoding::TypeMarker for VideoCompressedFormat {
24959 type Owned = Self;
24960
24961 #[inline(always)]
24962 fn inline_align(_context: fidl::encoding::Context) -> usize {
24963 8
24964 }
24965
24966 #[inline(always)]
24967 fn inline_size(_context: fidl::encoding::Context) -> usize {
24968 16
24969 }
24970 }
24971
24972 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoCompressedFormat, D>
24973 for &VideoCompressedFormat
24974 {
24975 #[inline]
24976 unsafe fn encode(
24977 self,
24978 encoder: &mut fidl::encoding::Encoder<'_, D>,
24979 offset: usize,
24980 _depth: fidl::encoding::Depth,
24981 ) -> fidl::Result<()> {
24982 encoder.debug_check_bounds::<VideoCompressedFormat>(offset);
24983 encoder.write_num::<u64>(self.ordinal(), offset);
24984 match self {
24985 VideoCompressedFormat::TempFieldTodoRemove(ref val) => {
24986 fidl::encoding::encode_in_envelope::<u32, D>(
24987 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
24988 encoder,
24989 offset + 8,
24990 _depth,
24991 )
24992 }
24993 }
24994 }
24995 }
24996
24997 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoCompressedFormat {
24998 #[inline(always)]
24999 fn new_empty() -> Self {
25000 Self::TempFieldTodoRemove(fidl::new_empty!(u32, D))
25001 }
25002
25003 #[inline]
25004 unsafe fn decode(
25005 &mut self,
25006 decoder: &mut fidl::encoding::Decoder<'_, D>,
25007 offset: usize,
25008 mut depth: fidl::encoding::Depth,
25009 ) -> fidl::Result<()> {
25010 decoder.debug_check_bounds::<Self>(offset);
25011 #[allow(unused_variables)]
25012 let next_out_of_line = decoder.next_out_of_line();
25013 let handles_before = decoder.remaining_handles();
25014 let (ordinal, inlined, num_bytes, num_handles) =
25015 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25016
25017 let member_inline_size = match ordinal {
25018 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25019 _ => return Err(fidl::Error::UnknownUnionTag),
25020 };
25021
25022 if inlined != (member_inline_size <= 4) {
25023 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25024 }
25025 let _inner_offset;
25026 if inlined {
25027 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25028 _inner_offset = offset + 8;
25029 } else {
25030 depth.increment()?;
25031 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25032 }
25033 match ordinal {
25034 1 => {
25035 #[allow(irrefutable_let_patterns)]
25036 if let VideoCompressedFormat::TempFieldTodoRemove(_) = self {
25037 } else {
25039 *self =
25041 VideoCompressedFormat::TempFieldTodoRemove(fidl::new_empty!(u32, D));
25042 }
25043 #[allow(irrefutable_let_patterns)]
25044 if let VideoCompressedFormat::TempFieldTodoRemove(ref mut val) = self {
25045 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
25046 } else {
25047 unreachable!()
25048 }
25049 }
25050 ordinal => panic!("unexpected ordinal {:?}", ordinal),
25051 }
25052 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25053 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25054 }
25055 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25056 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25057 }
25058 Ok(())
25059 }
25060 }
25061
25062 impl fidl::encoding::ValueTypeMarker for VideoFormat {
25063 type Borrowed<'a> = &'a Self;
25064 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25065 value
25066 }
25067 }
25068
25069 unsafe impl fidl::encoding::TypeMarker for VideoFormat {
25070 type Owned = Self;
25071
25072 #[inline(always)]
25073 fn inline_align(_context: fidl::encoding::Context) -> usize {
25074 8
25075 }
25076
25077 #[inline(always)]
25078 fn inline_size(_context: fidl::encoding::Context) -> usize {
25079 16
25080 }
25081 }
25082
25083 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoFormat, D>
25084 for &VideoFormat
25085 {
25086 #[inline]
25087 unsafe fn encode(
25088 self,
25089 encoder: &mut fidl::encoding::Encoder<'_, D>,
25090 offset: usize,
25091 _depth: fidl::encoding::Depth,
25092 ) -> fidl::Result<()> {
25093 encoder.debug_check_bounds::<VideoFormat>(offset);
25094 encoder.write_num::<u64>(self.ordinal(), offset);
25095 match self {
25096 VideoFormat::Compressed(ref val) => {
25097 fidl::encoding::encode_in_envelope::<VideoCompressedFormat, D>(
25098 <VideoCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
25099 encoder,
25100 offset + 8,
25101 _depth,
25102 )
25103 }
25104 VideoFormat::Uncompressed(ref val) => {
25105 fidl::encoding::encode_in_envelope::<VideoUncompressedFormat, D>(
25106 <VideoUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
25107 encoder,
25108 offset + 8,
25109 _depth,
25110 )
25111 }
25112 }
25113 }
25114 }
25115
25116 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoFormat {
25117 #[inline(always)]
25118 fn new_empty() -> Self {
25119 Self::Compressed(fidl::new_empty!(VideoCompressedFormat, D))
25120 }
25121
25122 #[inline]
25123 unsafe fn decode(
25124 &mut self,
25125 decoder: &mut fidl::encoding::Decoder<'_, D>,
25126 offset: usize,
25127 mut depth: fidl::encoding::Depth,
25128 ) -> fidl::Result<()> {
25129 decoder.debug_check_bounds::<Self>(offset);
25130 #[allow(unused_variables)]
25131 let next_out_of_line = decoder.next_out_of_line();
25132 let handles_before = decoder.remaining_handles();
25133 let (ordinal, inlined, num_bytes, num_handles) =
25134 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25135
25136 let member_inline_size = match ordinal {
25137 1 => <VideoCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
25138 decoder.context,
25139 ),
25140 2 => <VideoUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
25141 decoder.context,
25142 ),
25143 _ => return Err(fidl::Error::UnknownUnionTag),
25144 };
25145
25146 if inlined != (member_inline_size <= 4) {
25147 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25148 }
25149 let _inner_offset;
25150 if inlined {
25151 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25152 _inner_offset = offset + 8;
25153 } else {
25154 depth.increment()?;
25155 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25156 }
25157 match ordinal {
25158 1 => {
25159 #[allow(irrefutable_let_patterns)]
25160 if let VideoFormat::Compressed(_) = self {
25161 } else {
25163 *self = VideoFormat::Compressed(fidl::new_empty!(VideoCompressedFormat, D));
25165 }
25166 #[allow(irrefutable_let_patterns)]
25167 if let VideoFormat::Compressed(ref mut val) = self {
25168 fidl::decode!(
25169 VideoCompressedFormat,
25170 D,
25171 val,
25172 decoder,
25173 _inner_offset,
25174 depth
25175 )?;
25176 } else {
25177 unreachable!()
25178 }
25179 }
25180 2 => {
25181 #[allow(irrefutable_let_patterns)]
25182 if let VideoFormat::Uncompressed(_) = self {
25183 } else {
25185 *self =
25187 VideoFormat::Uncompressed(fidl::new_empty!(VideoUncompressedFormat, D));
25188 }
25189 #[allow(irrefutable_let_patterns)]
25190 if let VideoFormat::Uncompressed(ref mut val) = self {
25191 fidl::decode!(
25192 VideoUncompressedFormat,
25193 D,
25194 val,
25195 decoder,
25196 _inner_offset,
25197 depth
25198 )?;
25199 } else {
25200 unreachable!()
25201 }
25202 }
25203 ordinal => panic!("unexpected ordinal {:?}", ordinal),
25204 }
25205 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25206 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25207 }
25208 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25209 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25210 }
25211 Ok(())
25212 }
25213 }
25214}