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
3386mod internal {
3387 use super::*;
3388 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartFlags {
3389 type Owned = Self;
3390
3391 #[inline(always)]
3392 fn inline_align(_context: fidl::encoding::Context) -> usize {
3393 4
3394 }
3395
3396 #[inline(always)]
3397 fn inline_size(_context: fidl::encoding::Context) -> usize {
3398 4
3399 }
3400 }
3401
3402 impl fidl::encoding::ValueTypeMarker for AudioConsumerStartFlags {
3403 type Borrowed<'a> = Self;
3404 #[inline(always)]
3405 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3406 *value
3407 }
3408 }
3409
3410 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3411 for AudioConsumerStartFlags
3412 {
3413 #[inline]
3414 unsafe fn encode(
3415 self,
3416 encoder: &mut fidl::encoding::Encoder<'_, D>,
3417 offset: usize,
3418 _depth: fidl::encoding::Depth,
3419 ) -> fidl::Result<()> {
3420 encoder.debug_check_bounds::<Self>(offset);
3421 if self.bits() & Self::all().bits() != self.bits() {
3422 return Err(fidl::Error::InvalidBitsValue);
3423 }
3424 encoder.write_num(self.bits(), offset);
3425 Ok(())
3426 }
3427 }
3428
3429 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3430 for AudioConsumerStartFlags
3431 {
3432 #[inline(always)]
3433 fn new_empty() -> Self {
3434 Self::empty()
3435 }
3436
3437 #[inline]
3438 unsafe fn decode(
3439 &mut self,
3440 decoder: &mut fidl::encoding::Decoder<'_, D>,
3441 offset: usize,
3442 _depth: fidl::encoding::Depth,
3443 ) -> fidl::Result<()> {
3444 decoder.debug_check_bounds::<Self>(offset);
3445 let prim = decoder.read_num::<u32>(offset);
3446 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3447 Ok(())
3448 }
3449 }
3450 unsafe impl fidl::encoding::TypeMarker for AudioGainInfoFlags {
3451 type Owned = Self;
3452
3453 #[inline(always)]
3454 fn inline_align(_context: fidl::encoding::Context) -> usize {
3455 4
3456 }
3457
3458 #[inline(always)]
3459 fn inline_size(_context: fidl::encoding::Context) -> usize {
3460 4
3461 }
3462 }
3463
3464 impl fidl::encoding::ValueTypeMarker for AudioGainInfoFlags {
3465 type Borrowed<'a> = Self;
3466 #[inline(always)]
3467 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3468 *value
3469 }
3470 }
3471
3472 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3473 for AudioGainInfoFlags
3474 {
3475 #[inline]
3476 unsafe fn encode(
3477 self,
3478 encoder: &mut fidl::encoding::Encoder<'_, D>,
3479 offset: usize,
3480 _depth: fidl::encoding::Depth,
3481 ) -> fidl::Result<()> {
3482 encoder.debug_check_bounds::<Self>(offset);
3483 if self.bits() & Self::all().bits() != self.bits() {
3484 return Err(fidl::Error::InvalidBitsValue);
3485 }
3486 encoder.write_num(self.bits(), offset);
3487 Ok(())
3488 }
3489 }
3490
3491 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfoFlags {
3492 #[inline(always)]
3493 fn new_empty() -> Self {
3494 Self::empty()
3495 }
3496
3497 #[inline]
3498 unsafe fn decode(
3499 &mut self,
3500 decoder: &mut fidl::encoding::Decoder<'_, D>,
3501 offset: usize,
3502 _depth: fidl::encoding::Depth,
3503 ) -> fidl::Result<()> {
3504 decoder.debug_check_bounds::<Self>(offset);
3505 let prim = decoder.read_num::<u32>(offset);
3506 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3507 Ok(())
3508 }
3509 }
3510 unsafe impl fidl::encoding::TypeMarker for AudioGainValidFlags {
3511 type Owned = Self;
3512
3513 #[inline(always)]
3514 fn inline_align(_context: fidl::encoding::Context) -> usize {
3515 4
3516 }
3517
3518 #[inline(always)]
3519 fn inline_size(_context: fidl::encoding::Context) -> usize {
3520 4
3521 }
3522 }
3523
3524 impl fidl::encoding::ValueTypeMarker for AudioGainValidFlags {
3525 type Borrowed<'a> = Self;
3526 #[inline(always)]
3527 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3528 *value
3529 }
3530 }
3531
3532 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3533 for AudioGainValidFlags
3534 {
3535 #[inline]
3536 unsafe fn encode(
3537 self,
3538 encoder: &mut fidl::encoding::Encoder<'_, D>,
3539 offset: usize,
3540 _depth: fidl::encoding::Depth,
3541 ) -> fidl::Result<()> {
3542 encoder.debug_check_bounds::<Self>(offset);
3543 if self.bits() & Self::all().bits() != self.bits() {
3544 return Err(fidl::Error::InvalidBitsValue);
3545 }
3546 encoder.write_num(self.bits(), offset);
3547 Ok(())
3548 }
3549 }
3550
3551 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainValidFlags {
3552 #[inline(always)]
3553 fn new_empty() -> Self {
3554 Self::empty()
3555 }
3556
3557 #[inline]
3558 unsafe fn decode(
3559 &mut self,
3560 decoder: &mut fidl::encoding::Decoder<'_, D>,
3561 offset: usize,
3562 _depth: fidl::encoding::Depth,
3563 ) -> fidl::Result<()> {
3564 decoder.debug_check_bounds::<Self>(offset);
3565 let prim = decoder.read_num::<u32>(offset);
3566 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3567 Ok(())
3568 }
3569 }
3570 unsafe impl fidl::encoding::TypeMarker for AacAudioObjectType {
3571 type Owned = Self;
3572
3573 #[inline(always)]
3574 fn inline_align(_context: fidl::encoding::Context) -> usize {
3575 std::mem::align_of::<u32>()
3576 }
3577
3578 #[inline(always)]
3579 fn inline_size(_context: fidl::encoding::Context) -> usize {
3580 std::mem::size_of::<u32>()
3581 }
3582
3583 #[inline(always)]
3584 fn encode_is_copy() -> bool {
3585 true
3586 }
3587
3588 #[inline(always)]
3589 fn decode_is_copy() -> bool {
3590 false
3591 }
3592 }
3593
3594 impl fidl::encoding::ValueTypeMarker for AacAudioObjectType {
3595 type Borrowed<'a> = Self;
3596 #[inline(always)]
3597 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3598 *value
3599 }
3600 }
3601
3602 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3603 for AacAudioObjectType
3604 {
3605 #[inline]
3606 unsafe fn encode(
3607 self,
3608 encoder: &mut fidl::encoding::Encoder<'_, D>,
3609 offset: usize,
3610 _depth: fidl::encoding::Depth,
3611 ) -> fidl::Result<()> {
3612 encoder.debug_check_bounds::<Self>(offset);
3613 encoder.write_num(self.into_primitive(), offset);
3614 Ok(())
3615 }
3616 }
3617
3618 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacAudioObjectType {
3619 #[inline(always)]
3620 fn new_empty() -> Self {
3621 Self::Mpeg2AacLc
3622 }
3623
3624 #[inline]
3625 unsafe fn decode(
3626 &mut self,
3627 decoder: &mut fidl::encoding::Decoder<'_, D>,
3628 offset: usize,
3629 _depth: fidl::encoding::Depth,
3630 ) -> fidl::Result<()> {
3631 decoder.debug_check_bounds::<Self>(offset);
3632 let prim = decoder.read_num::<u32>(offset);
3633
3634 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3635 Ok(())
3636 }
3637 }
3638 unsafe impl fidl::encoding::TypeMarker for AacChannelMode {
3639 type Owned = Self;
3640
3641 #[inline(always)]
3642 fn inline_align(_context: fidl::encoding::Context) -> usize {
3643 std::mem::align_of::<u32>()
3644 }
3645
3646 #[inline(always)]
3647 fn inline_size(_context: fidl::encoding::Context) -> usize {
3648 std::mem::size_of::<u32>()
3649 }
3650
3651 #[inline(always)]
3652 fn encode_is_copy() -> bool {
3653 true
3654 }
3655
3656 #[inline(always)]
3657 fn decode_is_copy() -> bool {
3658 false
3659 }
3660 }
3661
3662 impl fidl::encoding::ValueTypeMarker for AacChannelMode {
3663 type Borrowed<'a> = Self;
3664 #[inline(always)]
3665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3666 *value
3667 }
3668 }
3669
3670 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AacChannelMode {
3671 #[inline]
3672 unsafe fn encode(
3673 self,
3674 encoder: &mut fidl::encoding::Encoder<'_, D>,
3675 offset: usize,
3676 _depth: fidl::encoding::Depth,
3677 ) -> fidl::Result<()> {
3678 encoder.debug_check_bounds::<Self>(offset);
3679 encoder.write_num(self.into_primitive(), offset);
3680 Ok(())
3681 }
3682 }
3683
3684 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacChannelMode {
3685 #[inline(always)]
3686 fn new_empty() -> Self {
3687 Self::Mono
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
3700 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3701 Ok(())
3702 }
3703 }
3704 unsafe impl fidl::encoding::TypeMarker for AacVariableBitRate {
3705 type Owned = Self;
3706
3707 #[inline(always)]
3708 fn inline_align(_context: fidl::encoding::Context) -> usize {
3709 std::mem::align_of::<u32>()
3710 }
3711
3712 #[inline(always)]
3713 fn inline_size(_context: fidl::encoding::Context) -> usize {
3714 std::mem::size_of::<u32>()
3715 }
3716
3717 #[inline(always)]
3718 fn encode_is_copy() -> bool {
3719 true
3720 }
3721
3722 #[inline(always)]
3723 fn decode_is_copy() -> bool {
3724 false
3725 }
3726 }
3727
3728 impl fidl::encoding::ValueTypeMarker for AacVariableBitRate {
3729 type Borrowed<'a> = Self;
3730 #[inline(always)]
3731 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3732 *value
3733 }
3734 }
3735
3736 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3737 for AacVariableBitRate
3738 {
3739 #[inline]
3740 unsafe fn encode(
3741 self,
3742 encoder: &mut fidl::encoding::Encoder<'_, D>,
3743 offset: usize,
3744 _depth: fidl::encoding::Depth,
3745 ) -> fidl::Result<()> {
3746 encoder.debug_check_bounds::<Self>(offset);
3747 encoder.write_num(self.into_primitive(), offset);
3748 Ok(())
3749 }
3750 }
3751
3752 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacVariableBitRate {
3753 #[inline(always)]
3754 fn new_empty() -> Self {
3755 Self::V1
3756 }
3757
3758 #[inline]
3759 unsafe fn decode(
3760 &mut self,
3761 decoder: &mut fidl::encoding::Decoder<'_, D>,
3762 offset: usize,
3763 _depth: fidl::encoding::Depth,
3764 ) -> fidl::Result<()> {
3765 decoder.debug_check_bounds::<Self>(offset);
3766 let prim = decoder.read_num::<u32>(offset);
3767
3768 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3769 Ok(())
3770 }
3771 }
3772 unsafe impl fidl::encoding::TypeMarker for AudioBitrateMode {
3773 type Owned = Self;
3774
3775 #[inline(always)]
3776 fn inline_align(_context: fidl::encoding::Context) -> usize {
3777 std::mem::align_of::<u32>()
3778 }
3779
3780 #[inline(always)]
3781 fn inline_size(_context: fidl::encoding::Context) -> usize {
3782 std::mem::size_of::<u32>()
3783 }
3784
3785 #[inline(always)]
3786 fn encode_is_copy() -> bool {
3787 true
3788 }
3789
3790 #[inline(always)]
3791 fn decode_is_copy() -> bool {
3792 false
3793 }
3794 }
3795
3796 impl fidl::encoding::ValueTypeMarker for AudioBitrateMode {
3797 type Borrowed<'a> = Self;
3798 #[inline(always)]
3799 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3800 *value
3801 }
3802 }
3803
3804 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3805 for AudioBitrateMode
3806 {
3807 #[inline]
3808 unsafe fn encode(
3809 self,
3810 encoder: &mut fidl::encoding::Encoder<'_, D>,
3811 offset: usize,
3812 _depth: fidl::encoding::Depth,
3813 ) -> fidl::Result<()> {
3814 encoder.debug_check_bounds::<Self>(offset);
3815 encoder.write_num(self.into_primitive(), offset);
3816 Ok(())
3817 }
3818 }
3819
3820 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioBitrateMode {
3821 #[inline(always)]
3822 fn new_empty() -> Self {
3823 Self::Unspecified
3824 }
3825
3826 #[inline]
3827 unsafe fn decode(
3828 &mut self,
3829 decoder: &mut fidl::encoding::Decoder<'_, D>,
3830 offset: usize,
3831 _depth: fidl::encoding::Depth,
3832 ) -> fidl::Result<()> {
3833 decoder.debug_check_bounds::<Self>(offset);
3834 let prim = decoder.read_num::<u32>(offset);
3835
3836 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3837 Ok(())
3838 }
3839 }
3840 unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage {
3841 type Owned = Self;
3842
3843 #[inline(always)]
3844 fn inline_align(_context: fidl::encoding::Context) -> usize {
3845 std::mem::align_of::<u32>()
3846 }
3847
3848 #[inline(always)]
3849 fn inline_size(_context: fidl::encoding::Context) -> usize {
3850 std::mem::size_of::<u32>()
3851 }
3852
3853 #[inline(always)]
3854 fn encode_is_copy() -> bool {
3855 true
3856 }
3857
3858 #[inline(always)]
3859 fn decode_is_copy() -> bool {
3860 false
3861 }
3862 }
3863
3864 impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage {
3865 type Borrowed<'a> = Self;
3866 #[inline(always)]
3867 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3868 *value
3869 }
3870 }
3871
3872 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3873 for AudioCaptureUsage
3874 {
3875 #[inline]
3876 unsafe fn encode(
3877 self,
3878 encoder: &mut fidl::encoding::Encoder<'_, D>,
3879 offset: usize,
3880 _depth: fidl::encoding::Depth,
3881 ) -> fidl::Result<()> {
3882 encoder.debug_check_bounds::<Self>(offset);
3883 encoder.write_num(self.into_primitive(), offset);
3884 Ok(())
3885 }
3886 }
3887
3888 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage {
3889 #[inline(always)]
3890 fn new_empty() -> Self {
3891 Self::Background
3892 }
3893
3894 #[inline]
3895 unsafe fn decode(
3896 &mut self,
3897 decoder: &mut fidl::encoding::Decoder<'_, D>,
3898 offset: usize,
3899 _depth: fidl::encoding::Depth,
3900 ) -> fidl::Result<()> {
3901 decoder.debug_check_bounds::<Self>(offset);
3902 let prim = decoder.read_num::<u32>(offset);
3903
3904 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3905 Ok(())
3906 }
3907 }
3908 unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage2 {
3909 type Owned = Self;
3910
3911 #[inline(always)]
3912 fn inline_align(_context: fidl::encoding::Context) -> usize {
3913 std::mem::align_of::<u32>()
3914 }
3915
3916 #[inline(always)]
3917 fn inline_size(_context: fidl::encoding::Context) -> usize {
3918 std::mem::size_of::<u32>()
3919 }
3920
3921 #[inline(always)]
3922 fn encode_is_copy() -> bool {
3923 false
3924 }
3925
3926 #[inline(always)]
3927 fn decode_is_copy() -> bool {
3928 false
3929 }
3930 }
3931
3932 impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage2 {
3933 type Borrowed<'a> = Self;
3934 #[inline(always)]
3935 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3936 *value
3937 }
3938 }
3939
3940 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3941 for AudioCaptureUsage2
3942 {
3943 #[inline]
3944 unsafe fn encode(
3945 self,
3946 encoder: &mut fidl::encoding::Encoder<'_, D>,
3947 offset: usize,
3948 _depth: fidl::encoding::Depth,
3949 ) -> fidl::Result<()> {
3950 encoder.debug_check_bounds::<Self>(offset);
3951 encoder.write_num(self.into_primitive(), offset);
3952 Ok(())
3953 }
3954 }
3955
3956 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage2 {
3957 #[inline(always)]
3958 fn new_empty() -> Self {
3959 Self::unknown()
3960 }
3961
3962 #[inline]
3963 unsafe fn decode(
3964 &mut self,
3965 decoder: &mut fidl::encoding::Decoder<'_, D>,
3966 offset: usize,
3967 _depth: fidl::encoding::Depth,
3968 ) -> fidl::Result<()> {
3969 decoder.debug_check_bounds::<Self>(offset);
3970 let prim = decoder.read_num::<u32>(offset);
3971
3972 *self = Self::from_primitive_allow_unknown(prim);
3973 Ok(())
3974 }
3975 }
3976 unsafe impl fidl::encoding::TypeMarker for AudioChannelId {
3977 type Owned = Self;
3978
3979 #[inline(always)]
3980 fn inline_align(_context: fidl::encoding::Context) -> usize {
3981 std::mem::align_of::<u32>()
3982 }
3983
3984 #[inline(always)]
3985 fn inline_size(_context: fidl::encoding::Context) -> usize {
3986 std::mem::size_of::<u32>()
3987 }
3988
3989 #[inline(always)]
3990 fn encode_is_copy() -> bool {
3991 true
3992 }
3993
3994 #[inline(always)]
3995 fn decode_is_copy() -> bool {
3996 false
3997 }
3998 }
3999
4000 impl fidl::encoding::ValueTypeMarker for AudioChannelId {
4001 type Borrowed<'a> = Self;
4002 #[inline(always)]
4003 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4004 *value
4005 }
4006 }
4007
4008 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioChannelId {
4009 #[inline]
4010 unsafe fn encode(
4011 self,
4012 encoder: &mut fidl::encoding::Encoder<'_, D>,
4013 offset: usize,
4014 _depth: fidl::encoding::Depth,
4015 ) -> fidl::Result<()> {
4016 encoder.debug_check_bounds::<Self>(offset);
4017 encoder.write_num(self.into_primitive(), offset);
4018 Ok(())
4019 }
4020 }
4021
4022 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioChannelId {
4023 #[inline(always)]
4024 fn new_empty() -> Self {
4025 Self::Skip
4026 }
4027
4028 #[inline]
4029 unsafe fn decode(
4030 &mut self,
4031 decoder: &mut fidl::encoding::Decoder<'_, D>,
4032 offset: usize,
4033 _depth: fidl::encoding::Depth,
4034 ) -> fidl::Result<()> {
4035 decoder.debug_check_bounds::<Self>(offset);
4036 let prim = decoder.read_num::<u32>(offset);
4037
4038 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4039 Ok(())
4040 }
4041 }
4042 unsafe impl fidl::encoding::TypeMarker for AudioOutputRoutingPolicy {
4043 type Owned = Self;
4044
4045 #[inline(always)]
4046 fn inline_align(_context: fidl::encoding::Context) -> usize {
4047 std::mem::align_of::<u32>()
4048 }
4049
4050 #[inline(always)]
4051 fn inline_size(_context: fidl::encoding::Context) -> usize {
4052 std::mem::size_of::<u32>()
4053 }
4054
4055 #[inline(always)]
4056 fn encode_is_copy() -> bool {
4057 true
4058 }
4059
4060 #[inline(always)]
4061 fn decode_is_copy() -> bool {
4062 false
4063 }
4064 }
4065
4066 impl fidl::encoding::ValueTypeMarker for AudioOutputRoutingPolicy {
4067 type Borrowed<'a> = Self;
4068 #[inline(always)]
4069 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4070 *value
4071 }
4072 }
4073
4074 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4075 for AudioOutputRoutingPolicy
4076 {
4077 #[inline]
4078 unsafe fn encode(
4079 self,
4080 encoder: &mut fidl::encoding::Encoder<'_, D>,
4081 offset: usize,
4082 _depth: fidl::encoding::Depth,
4083 ) -> fidl::Result<()> {
4084 encoder.debug_check_bounds::<Self>(offset);
4085 encoder.write_num(self.into_primitive(), offset);
4086 Ok(())
4087 }
4088 }
4089
4090 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4091 for AudioOutputRoutingPolicy
4092 {
4093 #[inline(always)]
4094 fn new_empty() -> Self {
4095 Self::AllPluggedOutputs
4096 }
4097
4098 #[inline]
4099 unsafe fn decode(
4100 &mut self,
4101 decoder: &mut fidl::encoding::Decoder<'_, D>,
4102 offset: usize,
4103 _depth: fidl::encoding::Depth,
4104 ) -> fidl::Result<()> {
4105 decoder.debug_check_bounds::<Self>(offset);
4106 let prim = decoder.read_num::<u32>(offset);
4107
4108 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4109 Ok(())
4110 }
4111 }
4112 unsafe impl fidl::encoding::TypeMarker for AudioPcmMode {
4113 type Owned = Self;
4114
4115 #[inline(always)]
4116 fn inline_align(_context: fidl::encoding::Context) -> usize {
4117 std::mem::align_of::<u32>()
4118 }
4119
4120 #[inline(always)]
4121 fn inline_size(_context: fidl::encoding::Context) -> usize {
4122 std::mem::size_of::<u32>()
4123 }
4124
4125 #[inline(always)]
4126 fn encode_is_copy() -> bool {
4127 true
4128 }
4129
4130 #[inline(always)]
4131 fn decode_is_copy() -> bool {
4132 false
4133 }
4134 }
4135
4136 impl fidl::encoding::ValueTypeMarker for AudioPcmMode {
4137 type Borrowed<'a> = Self;
4138 #[inline(always)]
4139 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4140 *value
4141 }
4142 }
4143
4144 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioPcmMode {
4145 #[inline]
4146 unsafe fn encode(
4147 self,
4148 encoder: &mut fidl::encoding::Encoder<'_, D>,
4149 offset: usize,
4150 _depth: fidl::encoding::Depth,
4151 ) -> fidl::Result<()> {
4152 encoder.debug_check_bounds::<Self>(offset);
4153 encoder.write_num(self.into_primitive(), offset);
4154 Ok(())
4155 }
4156 }
4157
4158 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioPcmMode {
4159 #[inline(always)]
4160 fn new_empty() -> Self {
4161 Self::Linear
4162 }
4163
4164 #[inline]
4165 unsafe fn decode(
4166 &mut self,
4167 decoder: &mut fidl::encoding::Decoder<'_, D>,
4168 offset: usize,
4169 _depth: fidl::encoding::Depth,
4170 ) -> fidl::Result<()> {
4171 decoder.debug_check_bounds::<Self>(offset);
4172 let prim = decoder.read_num::<u32>(offset);
4173
4174 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4175 Ok(())
4176 }
4177 }
4178 unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage {
4179 type Owned = Self;
4180
4181 #[inline(always)]
4182 fn inline_align(_context: fidl::encoding::Context) -> usize {
4183 std::mem::align_of::<u32>()
4184 }
4185
4186 #[inline(always)]
4187 fn inline_size(_context: fidl::encoding::Context) -> usize {
4188 std::mem::size_of::<u32>()
4189 }
4190
4191 #[inline(always)]
4192 fn encode_is_copy() -> bool {
4193 true
4194 }
4195
4196 #[inline(always)]
4197 fn decode_is_copy() -> bool {
4198 false
4199 }
4200 }
4201
4202 impl fidl::encoding::ValueTypeMarker for AudioRenderUsage {
4203 type Borrowed<'a> = Self;
4204 #[inline(always)]
4205 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4206 *value
4207 }
4208 }
4209
4210 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4211 for AudioRenderUsage
4212 {
4213 #[inline]
4214 unsafe fn encode(
4215 self,
4216 encoder: &mut fidl::encoding::Encoder<'_, D>,
4217 offset: usize,
4218 _depth: fidl::encoding::Depth,
4219 ) -> fidl::Result<()> {
4220 encoder.debug_check_bounds::<Self>(offset);
4221 encoder.write_num(self.into_primitive(), offset);
4222 Ok(())
4223 }
4224 }
4225
4226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage {
4227 #[inline(always)]
4228 fn new_empty() -> Self {
4229 Self::Background
4230 }
4231
4232 #[inline]
4233 unsafe fn decode(
4234 &mut self,
4235 decoder: &mut fidl::encoding::Decoder<'_, D>,
4236 offset: usize,
4237 _depth: fidl::encoding::Depth,
4238 ) -> fidl::Result<()> {
4239 decoder.debug_check_bounds::<Self>(offset);
4240 let prim = decoder.read_num::<u32>(offset);
4241
4242 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4243 Ok(())
4244 }
4245 }
4246 unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage2 {
4247 type Owned = Self;
4248
4249 #[inline(always)]
4250 fn inline_align(_context: fidl::encoding::Context) -> usize {
4251 std::mem::align_of::<u32>()
4252 }
4253
4254 #[inline(always)]
4255 fn inline_size(_context: fidl::encoding::Context) -> usize {
4256 std::mem::size_of::<u32>()
4257 }
4258
4259 #[inline(always)]
4260 fn encode_is_copy() -> bool {
4261 false
4262 }
4263
4264 #[inline(always)]
4265 fn decode_is_copy() -> bool {
4266 false
4267 }
4268 }
4269
4270 impl fidl::encoding::ValueTypeMarker for AudioRenderUsage2 {
4271 type Borrowed<'a> = Self;
4272 #[inline(always)]
4273 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4274 *value
4275 }
4276 }
4277
4278 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4279 for AudioRenderUsage2
4280 {
4281 #[inline]
4282 unsafe fn encode(
4283 self,
4284 encoder: &mut fidl::encoding::Encoder<'_, D>,
4285 offset: usize,
4286 _depth: fidl::encoding::Depth,
4287 ) -> fidl::Result<()> {
4288 encoder.debug_check_bounds::<Self>(offset);
4289 encoder.write_num(self.into_primitive(), offset);
4290 Ok(())
4291 }
4292 }
4293
4294 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage2 {
4295 #[inline(always)]
4296 fn new_empty() -> Self {
4297 Self::unknown()
4298 }
4299
4300 #[inline]
4301 unsafe fn decode(
4302 &mut self,
4303 decoder: &mut fidl::encoding::Decoder<'_, D>,
4304 offset: usize,
4305 _depth: fidl::encoding::Depth,
4306 ) -> fidl::Result<()> {
4307 decoder.debug_check_bounds::<Self>(offset);
4308 let prim = decoder.read_num::<u32>(offset);
4309
4310 *self = Self::from_primitive_allow_unknown(prim);
4311 Ok(())
4312 }
4313 }
4314 unsafe impl fidl::encoding::TypeMarker for AudioSampleFormat {
4315 type Owned = Self;
4316
4317 #[inline(always)]
4318 fn inline_align(_context: fidl::encoding::Context) -> usize {
4319 std::mem::align_of::<u32>()
4320 }
4321
4322 #[inline(always)]
4323 fn inline_size(_context: fidl::encoding::Context) -> usize {
4324 std::mem::size_of::<u32>()
4325 }
4326
4327 #[inline(always)]
4328 fn encode_is_copy() -> bool {
4329 true
4330 }
4331
4332 #[inline(always)]
4333 fn decode_is_copy() -> bool {
4334 false
4335 }
4336 }
4337
4338 impl fidl::encoding::ValueTypeMarker for AudioSampleFormat {
4339 type Borrowed<'a> = Self;
4340 #[inline(always)]
4341 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4342 *value
4343 }
4344 }
4345
4346 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4347 for AudioSampleFormat
4348 {
4349 #[inline]
4350 unsafe fn encode(
4351 self,
4352 encoder: &mut fidl::encoding::Encoder<'_, D>,
4353 offset: usize,
4354 _depth: fidl::encoding::Depth,
4355 ) -> fidl::Result<()> {
4356 encoder.debug_check_bounds::<Self>(offset);
4357 encoder.write_num(self.into_primitive(), offset);
4358 Ok(())
4359 }
4360 }
4361
4362 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioSampleFormat {
4363 #[inline(always)]
4364 fn new_empty() -> Self {
4365 Self::Unsigned8
4366 }
4367
4368 #[inline]
4369 unsafe fn decode(
4370 &mut self,
4371 decoder: &mut fidl::encoding::Decoder<'_, D>,
4372 offset: usize,
4373 _depth: fidl::encoding::Depth,
4374 ) -> fidl::Result<()> {
4375 decoder.debug_check_bounds::<Self>(offset);
4376 let prim = decoder.read_num::<u32>(offset);
4377
4378 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4379 Ok(())
4380 }
4381 }
4382 unsafe impl fidl::encoding::TypeMarker for Behavior {
4383 type Owned = Self;
4384
4385 #[inline(always)]
4386 fn inline_align(_context: fidl::encoding::Context) -> usize {
4387 std::mem::align_of::<u32>()
4388 }
4389
4390 #[inline(always)]
4391 fn inline_size(_context: fidl::encoding::Context) -> usize {
4392 std::mem::size_of::<u32>()
4393 }
4394
4395 #[inline(always)]
4396 fn encode_is_copy() -> bool {
4397 false
4398 }
4399
4400 #[inline(always)]
4401 fn decode_is_copy() -> bool {
4402 false
4403 }
4404 }
4405
4406 impl fidl::encoding::ValueTypeMarker for Behavior {
4407 type Borrowed<'a> = Self;
4408 #[inline(always)]
4409 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4410 *value
4411 }
4412 }
4413
4414 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Behavior {
4415 #[inline]
4416 unsafe fn encode(
4417 self,
4418 encoder: &mut fidl::encoding::Encoder<'_, D>,
4419 offset: usize,
4420 _depth: fidl::encoding::Depth,
4421 ) -> fidl::Result<()> {
4422 encoder.debug_check_bounds::<Self>(offset);
4423 encoder.write_num(self.into_primitive(), offset);
4424 Ok(())
4425 }
4426 }
4427
4428 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Behavior {
4429 #[inline(always)]
4430 fn new_empty() -> Self {
4431 Self::unknown()
4432 }
4433
4434 #[inline]
4435 unsafe fn decode(
4436 &mut self,
4437 decoder: &mut fidl::encoding::Decoder<'_, D>,
4438 offset: usize,
4439 _depth: fidl::encoding::Depth,
4440 ) -> fidl::Result<()> {
4441 decoder.debug_check_bounds::<Self>(offset);
4442 let prim = decoder.read_num::<u32>(offset);
4443
4444 *self = Self::from_primitive_allow_unknown(prim);
4445 Ok(())
4446 }
4447 }
4448 unsafe impl fidl::encoding::TypeMarker for CodecProfile {
4449 type Owned = Self;
4450
4451 #[inline(always)]
4452 fn inline_align(_context: fidl::encoding::Context) -> usize {
4453 std::mem::align_of::<u32>()
4454 }
4455
4456 #[inline(always)]
4457 fn inline_size(_context: fidl::encoding::Context) -> usize {
4458 std::mem::size_of::<u32>()
4459 }
4460
4461 #[inline(always)]
4462 fn encode_is_copy() -> bool {
4463 false
4464 }
4465
4466 #[inline(always)]
4467 fn decode_is_copy() -> bool {
4468 false
4469 }
4470 }
4471
4472 impl fidl::encoding::ValueTypeMarker for CodecProfile {
4473 type Borrowed<'a> = Self;
4474 #[inline(always)]
4475 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4476 *value
4477 }
4478 }
4479
4480 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CodecProfile {
4481 #[inline]
4482 unsafe fn encode(
4483 self,
4484 encoder: &mut fidl::encoding::Encoder<'_, D>,
4485 offset: usize,
4486 _depth: fidl::encoding::Depth,
4487 ) -> fidl::Result<()> {
4488 encoder.debug_check_bounds::<Self>(offset);
4489 encoder.write_num(self.into_primitive(), offset);
4490 Ok(())
4491 }
4492 }
4493
4494 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CodecProfile {
4495 #[inline(always)]
4496 fn new_empty() -> Self {
4497 Self::unknown()
4498 }
4499
4500 #[inline]
4501 unsafe fn decode(
4502 &mut self,
4503 decoder: &mut fidl::encoding::Decoder<'_, D>,
4504 offset: usize,
4505 _depth: fidl::encoding::Depth,
4506 ) -> fidl::Result<()> {
4507 decoder.debug_check_bounds::<Self>(offset);
4508 let prim = decoder.read_num::<u32>(offset);
4509
4510 *self = Self::from_primitive_allow_unknown(prim);
4511 Ok(())
4512 }
4513 }
4514 unsafe impl fidl::encoding::TypeMarker for ColorSpace {
4515 type Owned = Self;
4516
4517 #[inline(always)]
4518 fn inline_align(_context: fidl::encoding::Context) -> usize {
4519 std::mem::align_of::<u32>()
4520 }
4521
4522 #[inline(always)]
4523 fn inline_size(_context: fidl::encoding::Context) -> usize {
4524 std::mem::size_of::<u32>()
4525 }
4526
4527 #[inline(always)]
4528 fn encode_is_copy() -> bool {
4529 true
4530 }
4531
4532 #[inline(always)]
4533 fn decode_is_copy() -> bool {
4534 false
4535 }
4536 }
4537
4538 impl fidl::encoding::ValueTypeMarker for ColorSpace {
4539 type Borrowed<'a> = Self;
4540 #[inline(always)]
4541 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4542 *value
4543 }
4544 }
4545
4546 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ColorSpace {
4547 #[inline]
4548 unsafe fn encode(
4549 self,
4550 encoder: &mut fidl::encoding::Encoder<'_, D>,
4551 offset: usize,
4552 _depth: fidl::encoding::Depth,
4553 ) -> fidl::Result<()> {
4554 encoder.debug_check_bounds::<Self>(offset);
4555 encoder.write_num(self.into_primitive(), offset);
4556 Ok(())
4557 }
4558 }
4559
4560 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorSpace {
4561 #[inline(always)]
4562 fn new_empty() -> Self {
4563 Self::Unknown
4564 }
4565
4566 #[inline]
4567 unsafe fn decode(
4568 &mut self,
4569 decoder: &mut fidl::encoding::Decoder<'_, D>,
4570 offset: usize,
4571 _depth: fidl::encoding::Depth,
4572 ) -> fidl::Result<()> {
4573 decoder.debug_check_bounds::<Self>(offset);
4574 let prim = decoder.read_num::<u32>(offset);
4575
4576 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4577 Ok(())
4578 }
4579 }
4580 unsafe impl fidl::encoding::TypeMarker for Lc3FrameDuration {
4581 type Owned = Self;
4582
4583 #[inline(always)]
4584 fn inline_align(_context: fidl::encoding::Context) -> usize {
4585 std::mem::align_of::<u32>()
4586 }
4587
4588 #[inline(always)]
4589 fn inline_size(_context: fidl::encoding::Context) -> usize {
4590 std::mem::size_of::<u32>()
4591 }
4592
4593 #[inline(always)]
4594 fn encode_is_copy() -> bool {
4595 false
4596 }
4597
4598 #[inline(always)]
4599 fn decode_is_copy() -> bool {
4600 false
4601 }
4602 }
4603
4604 impl fidl::encoding::ValueTypeMarker for Lc3FrameDuration {
4605 type Borrowed<'a> = Self;
4606 #[inline(always)]
4607 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4608 *value
4609 }
4610 }
4611
4612 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4613 for Lc3FrameDuration
4614 {
4615 #[inline]
4616 unsafe fn encode(
4617 self,
4618 encoder: &mut fidl::encoding::Encoder<'_, D>,
4619 offset: usize,
4620 _depth: fidl::encoding::Depth,
4621 ) -> fidl::Result<()> {
4622 encoder.debug_check_bounds::<Self>(offset);
4623 encoder.write_num(self.into_primitive(), offset);
4624 Ok(())
4625 }
4626 }
4627
4628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3FrameDuration {
4629 #[inline(always)]
4630 fn new_empty() -> Self {
4631 Self::unknown()
4632 }
4633
4634 #[inline]
4635 unsafe fn decode(
4636 &mut self,
4637 decoder: &mut fidl::encoding::Decoder<'_, D>,
4638 offset: usize,
4639 _depth: fidl::encoding::Depth,
4640 ) -> fidl::Result<()> {
4641 decoder.debug_check_bounds::<Self>(offset);
4642 let prim = decoder.read_num::<u32>(offset);
4643
4644 *self = Self::from_primitive_allow_unknown(prim);
4645 Ok(())
4646 }
4647 }
4648 unsafe impl fidl::encoding::TypeMarker for SbcAllocation {
4649 type Owned = Self;
4650
4651 #[inline(always)]
4652 fn inline_align(_context: fidl::encoding::Context) -> usize {
4653 std::mem::align_of::<u32>()
4654 }
4655
4656 #[inline(always)]
4657 fn inline_size(_context: fidl::encoding::Context) -> usize {
4658 std::mem::size_of::<u32>()
4659 }
4660
4661 #[inline(always)]
4662 fn encode_is_copy() -> bool {
4663 true
4664 }
4665
4666 #[inline(always)]
4667 fn decode_is_copy() -> bool {
4668 false
4669 }
4670 }
4671
4672 impl fidl::encoding::ValueTypeMarker for SbcAllocation {
4673 type Borrowed<'a> = Self;
4674 #[inline(always)]
4675 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4676 *value
4677 }
4678 }
4679
4680 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcAllocation {
4681 #[inline]
4682 unsafe fn encode(
4683 self,
4684 encoder: &mut fidl::encoding::Encoder<'_, D>,
4685 offset: usize,
4686 _depth: fidl::encoding::Depth,
4687 ) -> fidl::Result<()> {
4688 encoder.debug_check_bounds::<Self>(offset);
4689 encoder.write_num(self.into_primitive(), offset);
4690 Ok(())
4691 }
4692 }
4693
4694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcAllocation {
4695 #[inline(always)]
4696 fn new_empty() -> Self {
4697 Self::AllocLoudness
4698 }
4699
4700 #[inline]
4701 unsafe fn decode(
4702 &mut self,
4703 decoder: &mut fidl::encoding::Decoder<'_, D>,
4704 offset: usize,
4705 _depth: fidl::encoding::Depth,
4706 ) -> fidl::Result<()> {
4707 decoder.debug_check_bounds::<Self>(offset);
4708 let prim = decoder.read_num::<u32>(offset);
4709
4710 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4711 Ok(())
4712 }
4713 }
4714 unsafe impl fidl::encoding::TypeMarker for SbcBlockCount {
4715 type Owned = Self;
4716
4717 #[inline(always)]
4718 fn inline_align(_context: fidl::encoding::Context) -> usize {
4719 std::mem::align_of::<u32>()
4720 }
4721
4722 #[inline(always)]
4723 fn inline_size(_context: fidl::encoding::Context) -> usize {
4724 std::mem::size_of::<u32>()
4725 }
4726
4727 #[inline(always)]
4728 fn encode_is_copy() -> bool {
4729 true
4730 }
4731
4732 #[inline(always)]
4733 fn decode_is_copy() -> bool {
4734 false
4735 }
4736 }
4737
4738 impl fidl::encoding::ValueTypeMarker for SbcBlockCount {
4739 type Borrowed<'a> = Self;
4740 #[inline(always)]
4741 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4742 *value
4743 }
4744 }
4745
4746 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcBlockCount {
4747 #[inline]
4748 unsafe fn encode(
4749 self,
4750 encoder: &mut fidl::encoding::Encoder<'_, D>,
4751 offset: usize,
4752 _depth: fidl::encoding::Depth,
4753 ) -> fidl::Result<()> {
4754 encoder.debug_check_bounds::<Self>(offset);
4755 encoder.write_num(self.into_primitive(), offset);
4756 Ok(())
4757 }
4758 }
4759
4760 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcBlockCount {
4761 #[inline(always)]
4762 fn new_empty() -> Self {
4763 Self::BlockCount4
4764 }
4765
4766 #[inline]
4767 unsafe fn decode(
4768 &mut self,
4769 decoder: &mut fidl::encoding::Decoder<'_, D>,
4770 offset: usize,
4771 _depth: fidl::encoding::Depth,
4772 ) -> fidl::Result<()> {
4773 decoder.debug_check_bounds::<Self>(offset);
4774 let prim = decoder.read_num::<u32>(offset);
4775
4776 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4777 Ok(())
4778 }
4779 }
4780 unsafe impl fidl::encoding::TypeMarker for SbcChannelMode {
4781 type Owned = Self;
4782
4783 #[inline(always)]
4784 fn inline_align(_context: fidl::encoding::Context) -> usize {
4785 std::mem::align_of::<u32>()
4786 }
4787
4788 #[inline(always)]
4789 fn inline_size(_context: fidl::encoding::Context) -> usize {
4790 std::mem::size_of::<u32>()
4791 }
4792
4793 #[inline(always)]
4794 fn encode_is_copy() -> bool {
4795 true
4796 }
4797
4798 #[inline(always)]
4799 fn decode_is_copy() -> bool {
4800 false
4801 }
4802 }
4803
4804 impl fidl::encoding::ValueTypeMarker for SbcChannelMode {
4805 type Borrowed<'a> = Self;
4806 #[inline(always)]
4807 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4808 *value
4809 }
4810 }
4811
4812 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcChannelMode {
4813 #[inline]
4814 unsafe fn encode(
4815 self,
4816 encoder: &mut fidl::encoding::Encoder<'_, D>,
4817 offset: usize,
4818 _depth: fidl::encoding::Depth,
4819 ) -> fidl::Result<()> {
4820 encoder.debug_check_bounds::<Self>(offset);
4821 encoder.write_num(self.into_primitive(), offset);
4822 Ok(())
4823 }
4824 }
4825
4826 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcChannelMode {
4827 #[inline(always)]
4828 fn new_empty() -> Self {
4829 Self::Mono
4830 }
4831
4832 #[inline]
4833 unsafe fn decode(
4834 &mut self,
4835 decoder: &mut fidl::encoding::Decoder<'_, D>,
4836 offset: usize,
4837 _depth: fidl::encoding::Depth,
4838 ) -> fidl::Result<()> {
4839 decoder.debug_check_bounds::<Self>(offset);
4840 let prim = decoder.read_num::<u32>(offset);
4841
4842 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4843 Ok(())
4844 }
4845 }
4846 unsafe impl fidl::encoding::TypeMarker for SbcSubBands {
4847 type Owned = Self;
4848
4849 #[inline(always)]
4850 fn inline_align(_context: fidl::encoding::Context) -> usize {
4851 std::mem::align_of::<u32>()
4852 }
4853
4854 #[inline(always)]
4855 fn inline_size(_context: fidl::encoding::Context) -> usize {
4856 std::mem::size_of::<u32>()
4857 }
4858
4859 #[inline(always)]
4860 fn encode_is_copy() -> bool {
4861 true
4862 }
4863
4864 #[inline(always)]
4865 fn decode_is_copy() -> bool {
4866 false
4867 }
4868 }
4869
4870 impl fidl::encoding::ValueTypeMarker for SbcSubBands {
4871 type Borrowed<'a> = Self;
4872 #[inline(always)]
4873 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4874 *value
4875 }
4876 }
4877
4878 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcSubBands {
4879 #[inline]
4880 unsafe fn encode(
4881 self,
4882 encoder: &mut fidl::encoding::Encoder<'_, D>,
4883 offset: usize,
4884 _depth: fidl::encoding::Depth,
4885 ) -> fidl::Result<()> {
4886 encoder.debug_check_bounds::<Self>(offset);
4887 encoder.write_num(self.into_primitive(), offset);
4888 Ok(())
4889 }
4890 }
4891
4892 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcSubBands {
4893 #[inline(always)]
4894 fn new_empty() -> Self {
4895 Self::SubBands4
4896 }
4897
4898 #[inline]
4899 unsafe fn decode(
4900 &mut self,
4901 decoder: &mut fidl::encoding::Decoder<'_, D>,
4902 offset: usize,
4903 _depth: fidl::encoding::Depth,
4904 ) -> fidl::Result<()> {
4905 decoder.debug_check_bounds::<Self>(offset);
4906 let prim = decoder.read_num::<u32>(offset);
4907
4908 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4909 Ok(())
4910 }
4911 }
4912 unsafe impl fidl::encoding::TypeMarker for StreamError {
4913 type Owned = Self;
4914
4915 #[inline(always)]
4916 fn inline_align(_context: fidl::encoding::Context) -> usize {
4917 std::mem::align_of::<u32>()
4918 }
4919
4920 #[inline(always)]
4921 fn inline_size(_context: fidl::encoding::Context) -> usize {
4922 std::mem::size_of::<u32>()
4923 }
4924
4925 #[inline(always)]
4926 fn encode_is_copy() -> bool {
4927 true
4928 }
4929
4930 #[inline(always)]
4931 fn decode_is_copy() -> bool {
4932 false
4933 }
4934 }
4935
4936 impl fidl::encoding::ValueTypeMarker for StreamError {
4937 type Borrowed<'a> = Self;
4938 #[inline(always)]
4939 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4940 *value
4941 }
4942 }
4943
4944 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StreamError {
4945 #[inline]
4946 unsafe fn encode(
4947 self,
4948 encoder: &mut fidl::encoding::Encoder<'_, D>,
4949 offset: usize,
4950 _depth: fidl::encoding::Depth,
4951 ) -> fidl::Result<()> {
4952 encoder.debug_check_bounds::<Self>(offset);
4953 encoder.write_num(self.into_primitive(), offset);
4954 Ok(())
4955 }
4956 }
4957
4958 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamError {
4959 #[inline(always)]
4960 fn new_empty() -> Self {
4961 Self::Unknown
4962 }
4963
4964 #[inline]
4965 unsafe fn decode(
4966 &mut self,
4967 decoder: &mut fidl::encoding::Decoder<'_, D>,
4968 offset: usize,
4969 _depth: fidl::encoding::Depth,
4970 ) -> fidl::Result<()> {
4971 decoder.debug_check_bounds::<Self>(offset);
4972 let prim = decoder.read_num::<u32>(offset);
4973
4974 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4975 Ok(())
4976 }
4977 }
4978 unsafe impl fidl::encoding::TypeMarker for VideoColorSpace {
4979 type Owned = Self;
4980
4981 #[inline(always)]
4982 fn inline_align(_context: fidl::encoding::Context) -> usize {
4983 std::mem::align_of::<u32>()
4984 }
4985
4986 #[inline(always)]
4987 fn inline_size(_context: fidl::encoding::Context) -> usize {
4988 std::mem::size_of::<u32>()
4989 }
4990
4991 #[inline(always)]
4992 fn encode_is_copy() -> bool {
4993 true
4994 }
4995
4996 #[inline(always)]
4997 fn decode_is_copy() -> bool {
4998 false
4999 }
5000 }
5001
5002 impl fidl::encoding::ValueTypeMarker for VideoColorSpace {
5003 type Borrowed<'a> = Self;
5004 #[inline(always)]
5005 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5006 *value
5007 }
5008 }
5009
5010 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
5011 for VideoColorSpace
5012 {
5013 #[inline]
5014 unsafe fn encode(
5015 self,
5016 encoder: &mut fidl::encoding::Encoder<'_, D>,
5017 offset: usize,
5018 _depth: fidl::encoding::Depth,
5019 ) -> fidl::Result<()> {
5020 encoder.debug_check_bounds::<Self>(offset);
5021 encoder.write_num(self.into_primitive(), offset);
5022 Ok(())
5023 }
5024 }
5025
5026 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoColorSpace {
5027 #[inline(always)]
5028 fn new_empty() -> Self {
5029 Self::Invalid
5030 }
5031
5032 #[inline]
5033 unsafe fn decode(
5034 &mut self,
5035 decoder: &mut fidl::encoding::Decoder<'_, D>,
5036 offset: usize,
5037 _depth: fidl::encoding::Depth,
5038 ) -> fidl::Result<()> {
5039 decoder.debug_check_bounds::<Self>(offset);
5040 let prim = decoder.read_num::<u32>(offset);
5041
5042 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5043 Ok(())
5044 }
5045 }
5046
5047 impl fidl::encoding::ValueTypeMarker for AacConstantBitRate {
5048 type Borrowed<'a> = &'a Self;
5049 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5050 value
5051 }
5052 }
5053
5054 unsafe impl fidl::encoding::TypeMarker for AacConstantBitRate {
5055 type Owned = Self;
5056
5057 #[inline(always)]
5058 fn inline_align(_context: fidl::encoding::Context) -> usize {
5059 4
5060 }
5061
5062 #[inline(always)]
5063 fn inline_size(_context: fidl::encoding::Context) -> usize {
5064 4
5065 }
5066 #[inline(always)]
5067 fn encode_is_copy() -> bool {
5068 true
5069 }
5070
5071 #[inline(always)]
5072 fn decode_is_copy() -> bool {
5073 true
5074 }
5075 }
5076
5077 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacConstantBitRate, D>
5078 for &AacConstantBitRate
5079 {
5080 #[inline]
5081 unsafe fn encode(
5082 self,
5083 encoder: &mut fidl::encoding::Encoder<'_, D>,
5084 offset: usize,
5085 _depth: fidl::encoding::Depth,
5086 ) -> fidl::Result<()> {
5087 encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5088 unsafe {
5089 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5091 (buf_ptr as *mut AacConstantBitRate)
5092 .write_unaligned((self as *const AacConstantBitRate).read());
5093 }
5096 Ok(())
5097 }
5098 }
5099 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
5100 fidl::encoding::Encode<AacConstantBitRate, D> for (T0,)
5101 {
5102 #[inline]
5103 unsafe fn encode(
5104 self,
5105 encoder: &mut fidl::encoding::Encoder<'_, D>,
5106 offset: usize,
5107 depth: fidl::encoding::Depth,
5108 ) -> fidl::Result<()> {
5109 encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5110 self.0.encode(encoder, offset + 0, depth)?;
5114 Ok(())
5115 }
5116 }
5117
5118 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacConstantBitRate {
5119 #[inline(always)]
5120 fn new_empty() -> Self {
5121 Self { bit_rate: fidl::new_empty!(u32, D) }
5122 }
5123
5124 #[inline]
5125 unsafe fn decode(
5126 &mut self,
5127 decoder: &mut fidl::encoding::Decoder<'_, D>,
5128 offset: usize,
5129 _depth: fidl::encoding::Depth,
5130 ) -> fidl::Result<()> {
5131 decoder.debug_check_bounds::<Self>(offset);
5132 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5133 unsafe {
5136 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
5137 }
5138 Ok(())
5139 }
5140 }
5141
5142 impl fidl::encoding::ValueTypeMarker for AacEncoderSettings {
5143 type Borrowed<'a> = &'a Self;
5144 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5145 value
5146 }
5147 }
5148
5149 unsafe impl fidl::encoding::TypeMarker for AacEncoderSettings {
5150 type Owned = Self;
5151
5152 #[inline(always)]
5153 fn inline_align(_context: fidl::encoding::Context) -> usize {
5154 8
5155 }
5156
5157 #[inline(always)]
5158 fn inline_size(_context: fidl::encoding::Context) -> usize {
5159 48
5160 }
5161 }
5162
5163 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacEncoderSettings, D>
5164 for &AacEncoderSettings
5165 {
5166 #[inline]
5167 unsafe fn encode(
5168 self,
5169 encoder: &mut fidl::encoding::Encoder<'_, D>,
5170 offset: usize,
5171 _depth: fidl::encoding::Depth,
5172 ) -> fidl::Result<()> {
5173 encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5174 fidl::encoding::Encode::<AacEncoderSettings, D>::encode(
5176 (
5177 <AacTransport as fidl::encoding::ValueTypeMarker>::borrow(&self.transport),
5178 <AacChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
5179 <AacBitRate as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_rate),
5180 <AacAudioObjectType as fidl::encoding::ValueTypeMarker>::borrow(&self.aot),
5181 ),
5182 encoder,
5183 offset,
5184 _depth,
5185 )
5186 }
5187 }
5188 unsafe impl<
5189 D: fidl::encoding::ResourceDialect,
5190 T0: fidl::encoding::Encode<AacTransport, D>,
5191 T1: fidl::encoding::Encode<AacChannelMode, D>,
5192 T2: fidl::encoding::Encode<AacBitRate, D>,
5193 T3: fidl::encoding::Encode<AacAudioObjectType, D>,
5194 > fidl::encoding::Encode<AacEncoderSettings, D> for (T0, T1, T2, T3)
5195 {
5196 #[inline]
5197 unsafe fn encode(
5198 self,
5199 encoder: &mut fidl::encoding::Encoder<'_, D>,
5200 offset: usize,
5201 depth: fidl::encoding::Depth,
5202 ) -> fidl::Result<()> {
5203 encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5204 unsafe {
5207 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
5208 (ptr as *mut u64).write_unaligned(0);
5209 }
5210 unsafe {
5211 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
5212 (ptr as *mut u64).write_unaligned(0);
5213 }
5214 self.0.encode(encoder, offset + 0, depth)?;
5216 self.1.encode(encoder, offset + 16, depth)?;
5217 self.2.encode(encoder, offset + 24, depth)?;
5218 self.3.encode(encoder, offset + 40, depth)?;
5219 Ok(())
5220 }
5221 }
5222
5223 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacEncoderSettings {
5224 #[inline(always)]
5225 fn new_empty() -> Self {
5226 Self {
5227 transport: fidl::new_empty!(AacTransport, D),
5228 channel_mode: fidl::new_empty!(AacChannelMode, D),
5229 bit_rate: fidl::new_empty!(AacBitRate, D),
5230 aot: fidl::new_empty!(AacAudioObjectType, D),
5231 }
5232 }
5233
5234 #[inline]
5235 unsafe fn decode(
5236 &mut self,
5237 decoder: &mut fidl::encoding::Decoder<'_, D>,
5238 offset: usize,
5239 _depth: fidl::encoding::Depth,
5240 ) -> fidl::Result<()> {
5241 decoder.debug_check_bounds::<Self>(offset);
5242 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
5244 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5245 let mask = 0xffffffff00000000u64;
5246 let maskedval = padval & mask;
5247 if maskedval != 0 {
5248 return Err(fidl::Error::NonZeroPadding {
5249 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
5250 });
5251 }
5252 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
5253 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5254 let mask = 0xffffffff00000000u64;
5255 let maskedval = padval & mask;
5256 if maskedval != 0 {
5257 return Err(fidl::Error::NonZeroPadding {
5258 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
5259 });
5260 }
5261 fidl::decode!(AacTransport, D, &mut self.transport, decoder, offset + 0, _depth)?;
5262 fidl::decode!(AacChannelMode, D, &mut self.channel_mode, decoder, offset + 16, _depth)?;
5263 fidl::decode!(AacBitRate, D, &mut self.bit_rate, decoder, offset + 24, _depth)?;
5264 fidl::decode!(AacAudioObjectType, D, &mut self.aot, decoder, offset + 40, _depth)?;
5265 Ok(())
5266 }
5267 }
5268
5269 impl fidl::encoding::ValueTypeMarker for AacTransportAdts {
5270 type Borrowed<'a> = &'a Self;
5271 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5272 value
5273 }
5274 }
5275
5276 unsafe impl fidl::encoding::TypeMarker for AacTransportAdts {
5277 type Owned = Self;
5278
5279 #[inline(always)]
5280 fn inline_align(_context: fidl::encoding::Context) -> usize {
5281 1
5282 }
5283
5284 #[inline(always)]
5285 fn inline_size(_context: fidl::encoding::Context) -> usize {
5286 1
5287 }
5288 }
5289
5290 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportAdts, D>
5291 for &AacTransportAdts
5292 {
5293 #[inline]
5294 unsafe fn encode(
5295 self,
5296 encoder: &mut fidl::encoding::Encoder<'_, D>,
5297 offset: usize,
5298 _depth: fidl::encoding::Depth,
5299 ) -> fidl::Result<()> {
5300 encoder.debug_check_bounds::<AacTransportAdts>(offset);
5301 encoder.write_num(0u8, offset);
5302 Ok(())
5303 }
5304 }
5305
5306 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportAdts {
5307 #[inline(always)]
5308 fn new_empty() -> Self {
5309 Self
5310 }
5311
5312 #[inline]
5313 unsafe fn decode(
5314 &mut self,
5315 decoder: &mut fidl::encoding::Decoder<'_, D>,
5316 offset: usize,
5317 _depth: fidl::encoding::Depth,
5318 ) -> fidl::Result<()> {
5319 decoder.debug_check_bounds::<Self>(offset);
5320 match decoder.read_num::<u8>(offset) {
5321 0 => Ok(()),
5322 _ => Err(fidl::Error::Invalid),
5323 }
5324 }
5325 }
5326
5327 impl fidl::encoding::ValueTypeMarker for AacTransportLatm {
5328 type Borrowed<'a> = &'a Self;
5329 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5330 value
5331 }
5332 }
5333
5334 unsafe impl fidl::encoding::TypeMarker for AacTransportLatm {
5335 type Owned = Self;
5336
5337 #[inline(always)]
5338 fn inline_align(_context: fidl::encoding::Context) -> usize {
5339 1
5340 }
5341
5342 #[inline(always)]
5343 fn inline_size(_context: fidl::encoding::Context) -> usize {
5344 1
5345 }
5346 }
5347
5348 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportLatm, D>
5349 for &AacTransportLatm
5350 {
5351 #[inline]
5352 unsafe fn encode(
5353 self,
5354 encoder: &mut fidl::encoding::Encoder<'_, D>,
5355 offset: usize,
5356 _depth: fidl::encoding::Depth,
5357 ) -> fidl::Result<()> {
5358 encoder.debug_check_bounds::<AacTransportLatm>(offset);
5359 fidl::encoding::Encode::<AacTransportLatm, D>::encode(
5361 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.mux_config_present),),
5362 encoder,
5363 offset,
5364 _depth,
5365 )
5366 }
5367 }
5368 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
5369 fidl::encoding::Encode<AacTransportLatm, D> for (T0,)
5370 {
5371 #[inline]
5372 unsafe fn encode(
5373 self,
5374 encoder: &mut fidl::encoding::Encoder<'_, D>,
5375 offset: usize,
5376 depth: fidl::encoding::Depth,
5377 ) -> fidl::Result<()> {
5378 encoder.debug_check_bounds::<AacTransportLatm>(offset);
5379 self.0.encode(encoder, offset + 0, depth)?;
5383 Ok(())
5384 }
5385 }
5386
5387 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportLatm {
5388 #[inline(always)]
5389 fn new_empty() -> Self {
5390 Self { mux_config_present: fidl::new_empty!(bool, D) }
5391 }
5392
5393 #[inline]
5394 unsafe fn decode(
5395 &mut self,
5396 decoder: &mut fidl::encoding::Decoder<'_, D>,
5397 offset: usize,
5398 _depth: fidl::encoding::Depth,
5399 ) -> fidl::Result<()> {
5400 decoder.debug_check_bounds::<Self>(offset);
5401 fidl::decode!(bool, D, &mut self.mux_config_present, decoder, offset + 0, _depth)?;
5403 Ok(())
5404 }
5405 }
5406
5407 impl fidl::encoding::ValueTypeMarker for AacTransportRaw {
5408 type Borrowed<'a> = &'a Self;
5409 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5410 value
5411 }
5412 }
5413
5414 unsafe impl fidl::encoding::TypeMarker for AacTransportRaw {
5415 type Owned = Self;
5416
5417 #[inline(always)]
5418 fn inline_align(_context: fidl::encoding::Context) -> usize {
5419 1
5420 }
5421
5422 #[inline(always)]
5423 fn inline_size(_context: fidl::encoding::Context) -> usize {
5424 1
5425 }
5426 }
5427
5428 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportRaw, D>
5429 for &AacTransportRaw
5430 {
5431 #[inline]
5432 unsafe fn encode(
5433 self,
5434 encoder: &mut fidl::encoding::Encoder<'_, D>,
5435 offset: usize,
5436 _depth: fidl::encoding::Depth,
5437 ) -> fidl::Result<()> {
5438 encoder.debug_check_bounds::<AacTransportRaw>(offset);
5439 encoder.write_num(0u8, offset);
5440 Ok(())
5441 }
5442 }
5443
5444 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportRaw {
5445 #[inline(always)]
5446 fn new_empty() -> Self {
5447 Self
5448 }
5449
5450 #[inline]
5451 unsafe fn decode(
5452 &mut self,
5453 decoder: &mut fidl::encoding::Decoder<'_, D>,
5454 offset: usize,
5455 _depth: fidl::encoding::Depth,
5456 ) -> fidl::Result<()> {
5457 decoder.debug_check_bounds::<Self>(offset);
5458 match decoder.read_num::<u8>(offset) {
5459 0 => Ok(()),
5460 _ => Err(fidl::Error::Invalid),
5461 }
5462 }
5463 }
5464
5465 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivityResponse {
5466 type Borrowed<'a> = &'a Self;
5467 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5468 value
5469 }
5470 }
5471
5472 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivityResponse {
5473 type Owned = Self;
5474
5475 #[inline(always)]
5476 fn inline_align(_context: fidl::encoding::Context) -> usize {
5477 8
5478 }
5479
5480 #[inline(always)]
5481 fn inline_size(_context: fidl::encoding::Context) -> usize {
5482 16
5483 }
5484 }
5485
5486 unsafe impl<D: fidl::encoding::ResourceDialect>
5487 fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D>
5488 for &ActivityReporterWatchCaptureActivityResponse
5489 {
5490 #[inline]
5491 unsafe fn encode(
5492 self,
5493 encoder: &mut fidl::encoding::Encoder<'_, D>,
5494 offset: usize,
5495 _depth: fidl::encoding::Depth,
5496 ) -> fidl::Result<()> {
5497 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5498 fidl::encoding::Encode::<ActivityReporterWatchCaptureActivityResponse, D>::encode(
5500 (
5501 <fidl::encoding::Vector<AudioCaptureUsage, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5502 ),
5503 encoder, offset, _depth
5504 )
5505 }
5506 }
5507 unsafe impl<
5508 D: fidl::encoding::ResourceDialect,
5509 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage, 4>, D>,
5510 > fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D> for (T0,)
5511 {
5512 #[inline]
5513 unsafe fn encode(
5514 self,
5515 encoder: &mut fidl::encoding::Encoder<'_, D>,
5516 offset: usize,
5517 depth: fidl::encoding::Depth,
5518 ) -> fidl::Result<()> {
5519 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5520 self.0.encode(encoder, offset + 0, depth)?;
5524 Ok(())
5525 }
5526 }
5527
5528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5529 for ActivityReporterWatchCaptureActivityResponse
5530 {
5531 #[inline(always)]
5532 fn new_empty() -> Self {
5533 Self {
5534 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D),
5535 }
5536 }
5537
5538 #[inline]
5539 unsafe fn decode(
5540 &mut self,
5541 decoder: &mut fidl::encoding::Decoder<'_, D>,
5542 offset: usize,
5543 _depth: fidl::encoding::Depth,
5544 ) -> fidl::Result<()> {
5545 decoder.debug_check_bounds::<Self>(offset);
5546 fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5548 Ok(())
5549 }
5550 }
5551
5552 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivityResponse {
5553 type Borrowed<'a> = &'a Self;
5554 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5555 value
5556 }
5557 }
5558
5559 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivityResponse {
5560 type Owned = Self;
5561
5562 #[inline(always)]
5563 fn inline_align(_context: fidl::encoding::Context) -> usize {
5564 8
5565 }
5566
5567 #[inline(always)]
5568 fn inline_size(_context: fidl::encoding::Context) -> usize {
5569 16
5570 }
5571 }
5572
5573 unsafe impl<D: fidl::encoding::ResourceDialect>
5574 fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D>
5575 for &ActivityReporterWatchRenderActivityResponse
5576 {
5577 #[inline]
5578 unsafe fn encode(
5579 self,
5580 encoder: &mut fidl::encoding::Encoder<'_, D>,
5581 offset: usize,
5582 _depth: fidl::encoding::Depth,
5583 ) -> fidl::Result<()> {
5584 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5585 fidl::encoding::Encode::<ActivityReporterWatchRenderActivityResponse, D>::encode(
5587 (
5588 <fidl::encoding::Vector<AudioRenderUsage, 5> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5589 ),
5590 encoder, offset, _depth
5591 )
5592 }
5593 }
5594 unsafe impl<
5595 D: fidl::encoding::ResourceDialect,
5596 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage, 5>, D>,
5597 > fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D> for (T0,)
5598 {
5599 #[inline]
5600 unsafe fn encode(
5601 self,
5602 encoder: &mut fidl::encoding::Encoder<'_, D>,
5603 offset: usize,
5604 depth: fidl::encoding::Depth,
5605 ) -> fidl::Result<()> {
5606 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5607 self.0.encode(encoder, offset + 0, depth)?;
5611 Ok(())
5612 }
5613 }
5614
5615 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5616 for ActivityReporterWatchRenderActivityResponse
5617 {
5618 #[inline(always)]
5619 fn new_empty() -> Self {
5620 Self { active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage, 5>, D) }
5621 }
5622
5623 #[inline]
5624 unsafe fn decode(
5625 &mut self,
5626 decoder: &mut fidl::encoding::Decoder<'_, D>,
5627 offset: usize,
5628 _depth: fidl::encoding::Depth,
5629 ) -> fidl::Result<()> {
5630 decoder.debug_check_bounds::<Self>(offset);
5631 fidl::decode!(fidl::encoding::Vector<AudioRenderUsage, 5>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5633 Ok(())
5634 }
5635 }
5636
5637 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivity2Response {
5638 type Borrowed<'a> = &'a Self;
5639 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5640 value
5641 }
5642 }
5643
5644 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivity2Response {
5645 type Owned = Self;
5646
5647 #[inline(always)]
5648 fn inline_align(_context: fidl::encoding::Context) -> usize {
5649 8
5650 }
5651
5652 #[inline(always)]
5653 fn inline_size(_context: fidl::encoding::Context) -> usize {
5654 16
5655 }
5656 }
5657
5658 unsafe impl<D: fidl::encoding::ResourceDialect>
5659 fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D>
5660 for &ActivityReporterWatchCaptureActivity2Response
5661 {
5662 #[inline]
5663 unsafe fn encode(
5664 self,
5665 encoder: &mut fidl::encoding::Encoder<'_, D>,
5666 offset: usize,
5667 _depth: fidl::encoding::Depth,
5668 ) -> fidl::Result<()> {
5669 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5670 fidl::encoding::Encode::<ActivityReporterWatchCaptureActivity2Response, D>::encode(
5672 (
5673 <fidl::encoding::Vector<AudioCaptureUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5674 ),
5675 encoder, offset, _depth
5676 )
5677 }
5678 }
5679 unsafe impl<
5680 D: fidl::encoding::ResourceDialect,
5681 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage2, 8>, D>,
5682 > fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D> for (T0,)
5683 {
5684 #[inline]
5685 unsafe fn encode(
5686 self,
5687 encoder: &mut fidl::encoding::Encoder<'_, D>,
5688 offset: usize,
5689 depth: fidl::encoding::Depth,
5690 ) -> fidl::Result<()> {
5691 encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5692 self.0.encode(encoder, offset + 0, depth)?;
5696 Ok(())
5697 }
5698 }
5699
5700 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5701 for ActivityReporterWatchCaptureActivity2Response
5702 {
5703 #[inline(always)]
5704 fn new_empty() -> Self {
5705 Self {
5706 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D),
5707 }
5708 }
5709
5710 #[inline]
5711 unsafe fn decode(
5712 &mut self,
5713 decoder: &mut fidl::encoding::Decoder<'_, D>,
5714 offset: usize,
5715 _depth: fidl::encoding::Depth,
5716 ) -> fidl::Result<()> {
5717 decoder.debug_check_bounds::<Self>(offset);
5718 fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5720 Ok(())
5721 }
5722 }
5723
5724 impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivity2Response {
5725 type Borrowed<'a> = &'a Self;
5726 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5727 value
5728 }
5729 }
5730
5731 unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivity2Response {
5732 type Owned = Self;
5733
5734 #[inline(always)]
5735 fn inline_align(_context: fidl::encoding::Context) -> usize {
5736 8
5737 }
5738
5739 #[inline(always)]
5740 fn inline_size(_context: fidl::encoding::Context) -> usize {
5741 16
5742 }
5743 }
5744
5745 unsafe impl<D: fidl::encoding::ResourceDialect>
5746 fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D>
5747 for &ActivityReporterWatchRenderActivity2Response
5748 {
5749 #[inline]
5750 unsafe fn encode(
5751 self,
5752 encoder: &mut fidl::encoding::Encoder<'_, D>,
5753 offset: usize,
5754 _depth: fidl::encoding::Depth,
5755 ) -> fidl::Result<()> {
5756 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5757 fidl::encoding::Encode::<ActivityReporterWatchRenderActivity2Response, D>::encode(
5759 (
5760 <fidl::encoding::Vector<AudioRenderUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5761 ),
5762 encoder, offset, _depth
5763 )
5764 }
5765 }
5766 unsafe impl<
5767 D: fidl::encoding::ResourceDialect,
5768 T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage2, 8>, D>,
5769 > fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D> for (T0,)
5770 {
5771 #[inline]
5772 unsafe fn encode(
5773 self,
5774 encoder: &mut fidl::encoding::Encoder<'_, D>,
5775 offset: usize,
5776 depth: fidl::encoding::Depth,
5777 ) -> fidl::Result<()> {
5778 encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5779 self.0.encode(encoder, offset + 0, depth)?;
5783 Ok(())
5784 }
5785 }
5786
5787 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5788 for ActivityReporterWatchRenderActivity2Response
5789 {
5790 #[inline(always)]
5791 fn new_empty() -> Self {
5792 Self {
5793 active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D),
5794 }
5795 }
5796
5797 #[inline]
5798 unsafe fn decode(
5799 &mut self,
5800 decoder: &mut fidl::encoding::Decoder<'_, D>,
5801 offset: usize,
5802 _depth: fidl::encoding::Depth,
5803 ) -> fidl::Result<()> {
5804 decoder.debug_check_bounds::<Self>(offset);
5805 fidl::decode!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5807 Ok(())
5808 }
5809 }
5810
5811 impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtRequest {
5812 type Borrowed<'a> = &'a Self;
5813 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5814 value
5815 }
5816 }
5817
5818 unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtRequest {
5819 type Owned = Self;
5820
5821 #[inline(always)]
5822 fn inline_align(_context: fidl::encoding::Context) -> usize {
5823 4
5824 }
5825
5826 #[inline(always)]
5827 fn inline_size(_context: fidl::encoding::Context) -> usize {
5828 12
5829 }
5830 #[inline(always)]
5831 fn encode_is_copy() -> bool {
5832 true
5833 }
5834
5835 #[inline(always)]
5836 fn decode_is_copy() -> bool {
5837 true
5838 }
5839 }
5840
5841 unsafe impl<D: fidl::encoding::ResourceDialect>
5842 fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D>
5843 for &AudioCapturerCaptureAtRequest
5844 {
5845 #[inline]
5846 unsafe fn encode(
5847 self,
5848 encoder: &mut fidl::encoding::Encoder<'_, D>,
5849 offset: usize,
5850 _depth: fidl::encoding::Depth,
5851 ) -> fidl::Result<()> {
5852 encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
5853 unsafe {
5854 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5856 (buf_ptr as *mut AudioCapturerCaptureAtRequest)
5857 .write_unaligned((self as *const AudioCapturerCaptureAtRequest).read());
5858 }
5861 Ok(())
5862 }
5863 }
5864 unsafe impl<
5865 D: fidl::encoding::ResourceDialect,
5866 T0: fidl::encoding::Encode<u32, D>,
5867 T1: fidl::encoding::Encode<u32, D>,
5868 T2: fidl::encoding::Encode<u32, D>,
5869 > fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D> for (T0, T1, T2)
5870 {
5871 #[inline]
5872 unsafe fn encode(
5873 self,
5874 encoder: &mut fidl::encoding::Encoder<'_, D>,
5875 offset: usize,
5876 depth: fidl::encoding::Depth,
5877 ) -> fidl::Result<()> {
5878 encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
5879 self.0.encode(encoder, offset + 0, depth)?;
5883 self.1.encode(encoder, offset + 4, depth)?;
5884 self.2.encode(encoder, offset + 8, depth)?;
5885 Ok(())
5886 }
5887 }
5888
5889 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5890 for AudioCapturerCaptureAtRequest
5891 {
5892 #[inline(always)]
5893 fn new_empty() -> Self {
5894 Self {
5895 payload_buffer_id: fidl::new_empty!(u32, D),
5896 payload_offset: fidl::new_empty!(u32, D),
5897 frames: fidl::new_empty!(u32, D),
5898 }
5899 }
5900
5901 #[inline]
5902 unsafe fn decode(
5903 &mut self,
5904 decoder: &mut fidl::encoding::Decoder<'_, D>,
5905 offset: usize,
5906 _depth: fidl::encoding::Depth,
5907 ) -> fidl::Result<()> {
5908 decoder.debug_check_bounds::<Self>(offset);
5909 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5910 unsafe {
5913 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
5914 }
5915 Ok(())
5916 }
5917 }
5918
5919 impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtResponse {
5920 type Borrowed<'a> = &'a Self;
5921 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5922 value
5923 }
5924 }
5925
5926 unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtResponse {
5927 type Owned = Self;
5928
5929 #[inline(always)]
5930 fn inline_align(_context: fidl::encoding::Context) -> usize {
5931 8
5932 }
5933
5934 #[inline(always)]
5935 fn inline_size(_context: fidl::encoding::Context) -> usize {
5936 56
5937 }
5938 }
5939
5940 unsafe impl<D: fidl::encoding::ResourceDialect>
5941 fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D>
5942 for &AudioCapturerCaptureAtResponse
5943 {
5944 #[inline]
5945 unsafe fn encode(
5946 self,
5947 encoder: &mut fidl::encoding::Encoder<'_, D>,
5948 offset: usize,
5949 _depth: fidl::encoding::Depth,
5950 ) -> fidl::Result<()> {
5951 encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
5952 unsafe {
5953 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5955 (buf_ptr as *mut AudioCapturerCaptureAtResponse)
5956 .write_unaligned((self as *const AudioCapturerCaptureAtResponse).read());
5957 let padding_ptr = buf_ptr.offset(8) as *mut u64;
5960 let padding_mask = 0xffffffff00000000u64;
5961 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
5962 let padding_ptr = buf_ptr.offset(32) as *mut u64;
5963 let padding_mask = 0xffffffff00000000u64;
5964 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
5965 }
5966 Ok(())
5967 }
5968 }
5969 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
5970 fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D> for (T0,)
5971 {
5972 #[inline]
5973 unsafe fn encode(
5974 self,
5975 encoder: &mut fidl::encoding::Encoder<'_, D>,
5976 offset: usize,
5977 depth: fidl::encoding::Depth,
5978 ) -> fidl::Result<()> {
5979 encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
5980 self.0.encode(encoder, offset + 0, depth)?;
5984 Ok(())
5985 }
5986 }
5987
5988 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5989 for AudioCapturerCaptureAtResponse
5990 {
5991 #[inline(always)]
5992 fn new_empty() -> Self {
5993 Self { captured_packet: fidl::new_empty!(StreamPacket, D) }
5994 }
5995
5996 #[inline]
5997 unsafe fn decode(
5998 &mut self,
5999 decoder: &mut fidl::encoding::Decoder<'_, D>,
6000 offset: usize,
6001 _depth: fidl::encoding::Depth,
6002 ) -> fidl::Result<()> {
6003 decoder.debug_check_bounds::<Self>(offset);
6004 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6005 let ptr = unsafe { buf_ptr.offset(8) };
6007 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6008 let mask = 0xffffffff00000000u64;
6009 let maskedval = padval & mask;
6010 if maskedval != 0 {
6011 return Err(fidl::Error::NonZeroPadding {
6012 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
6013 });
6014 }
6015 let ptr = unsafe { buf_ptr.offset(32) };
6016 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6017 let mask = 0xffffffff00000000u64;
6018 let maskedval = padval & mask;
6019 if maskedval != 0 {
6020 return Err(fidl::Error::NonZeroPadding {
6021 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
6022 });
6023 }
6024 unsafe {
6026 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
6027 }
6028 Ok(())
6029 }
6030 }
6031
6032 impl fidl::encoding::ValueTypeMarker for AudioCapturerGetStreamTypeResponse {
6033 type Borrowed<'a> = &'a Self;
6034 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6035 value
6036 }
6037 }
6038
6039 unsafe impl fidl::encoding::TypeMarker for AudioCapturerGetStreamTypeResponse {
6040 type Owned = Self;
6041
6042 #[inline(always)]
6043 fn inline_align(_context: fidl::encoding::Context) -> usize {
6044 8
6045 }
6046
6047 #[inline(always)]
6048 fn inline_size(_context: fidl::encoding::Context) -> usize {
6049 48
6050 }
6051 }
6052
6053 unsafe impl<D: fidl::encoding::ResourceDialect>
6054 fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D>
6055 for &AudioCapturerGetStreamTypeResponse
6056 {
6057 #[inline]
6058 unsafe fn encode(
6059 self,
6060 encoder: &mut fidl::encoding::Encoder<'_, D>,
6061 offset: usize,
6062 _depth: fidl::encoding::Depth,
6063 ) -> fidl::Result<()> {
6064 encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6065 fidl::encoding::Encode::<AudioCapturerGetStreamTypeResponse, D>::encode(
6067 (<StreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6068 encoder,
6069 offset,
6070 _depth,
6071 )
6072 }
6073 }
6074 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamType, D>>
6075 fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D> for (T0,)
6076 {
6077 #[inline]
6078 unsafe fn encode(
6079 self,
6080 encoder: &mut fidl::encoding::Encoder<'_, D>,
6081 offset: usize,
6082 depth: fidl::encoding::Depth,
6083 ) -> fidl::Result<()> {
6084 encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6085 self.0.encode(encoder, offset + 0, depth)?;
6089 Ok(())
6090 }
6091 }
6092
6093 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6094 for AudioCapturerGetStreamTypeResponse
6095 {
6096 #[inline(always)]
6097 fn new_empty() -> Self {
6098 Self { stream_type: fidl::new_empty!(StreamType, D) }
6099 }
6100
6101 #[inline]
6102 unsafe fn decode(
6103 &mut self,
6104 decoder: &mut fidl::encoding::Decoder<'_, D>,
6105 offset: usize,
6106 _depth: fidl::encoding::Depth,
6107 ) -> fidl::Result<()> {
6108 decoder.debug_check_bounds::<Self>(offset);
6109 fidl::decode!(StreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6111 Ok(())
6112 }
6113 }
6114
6115 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6116 type Borrowed<'a> = &'a Self;
6117 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6118 value
6119 }
6120 }
6121
6122 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6123 type Owned = Self;
6124
6125 #[inline(always)]
6126 fn inline_align(_context: fidl::encoding::Context) -> usize {
6127 4
6128 }
6129
6130 #[inline(always)]
6131 fn inline_size(_context: fidl::encoding::Context) -> usize {
6132 12
6133 }
6134 }
6135
6136 unsafe impl<D: fidl::encoding::ResourceDialect>
6137 fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D>
6138 for &AudioCapturerSetPcmStreamTypeRequest
6139 {
6140 #[inline]
6141 unsafe fn encode(
6142 self,
6143 encoder: &mut fidl::encoding::Encoder<'_, D>,
6144 offset: usize,
6145 _depth: fidl::encoding::Depth,
6146 ) -> fidl::Result<()> {
6147 encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6148 fidl::encoding::Encode::<AudioCapturerSetPcmStreamTypeRequest, D>::encode(
6150 (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6151 encoder,
6152 offset,
6153 _depth,
6154 )
6155 }
6156 }
6157 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
6158 fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D> for (T0,)
6159 {
6160 #[inline]
6161 unsafe fn encode(
6162 self,
6163 encoder: &mut fidl::encoding::Encoder<'_, D>,
6164 offset: usize,
6165 depth: fidl::encoding::Depth,
6166 ) -> fidl::Result<()> {
6167 encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6168 self.0.encode(encoder, offset + 0, depth)?;
6172 Ok(())
6173 }
6174 }
6175
6176 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6177 for AudioCapturerSetPcmStreamTypeRequest
6178 {
6179 #[inline(always)]
6180 fn new_empty() -> Self {
6181 Self { stream_type: fidl::new_empty!(AudioStreamType, D) }
6182 }
6183
6184 #[inline]
6185 unsafe fn decode(
6186 &mut self,
6187 decoder: &mut fidl::encoding::Decoder<'_, D>,
6188 offset: usize,
6189 _depth: fidl::encoding::Depth,
6190 ) -> fidl::Result<()> {
6191 decoder.debug_check_bounds::<Self>(offset);
6192 fidl::decode!(AudioStreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6194 Ok(())
6195 }
6196 }
6197
6198 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsage2Request {
6199 type Borrowed<'a> = &'a Self;
6200 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6201 value
6202 }
6203 }
6204
6205 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsage2Request {
6206 type Owned = Self;
6207
6208 #[inline(always)]
6209 fn inline_align(_context: fidl::encoding::Context) -> usize {
6210 4
6211 }
6212
6213 #[inline(always)]
6214 fn inline_size(_context: fidl::encoding::Context) -> usize {
6215 4
6216 }
6217 }
6218
6219 unsafe impl<D: fidl::encoding::ResourceDialect>
6220 fidl::encoding::Encode<AudioCapturerSetUsage2Request, D>
6221 for &AudioCapturerSetUsage2Request
6222 {
6223 #[inline]
6224 unsafe fn encode(
6225 self,
6226 encoder: &mut fidl::encoding::Encoder<'_, D>,
6227 offset: usize,
6228 _depth: fidl::encoding::Depth,
6229 ) -> fidl::Result<()> {
6230 encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6231 fidl::encoding::Encode::<AudioCapturerSetUsage2Request, D>::encode(
6233 (<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6234 encoder,
6235 offset,
6236 _depth,
6237 )
6238 }
6239 }
6240 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage2, D>>
6241 fidl::encoding::Encode<AudioCapturerSetUsage2Request, D> for (T0,)
6242 {
6243 #[inline]
6244 unsafe fn encode(
6245 self,
6246 encoder: &mut fidl::encoding::Encoder<'_, D>,
6247 offset: usize,
6248 depth: fidl::encoding::Depth,
6249 ) -> fidl::Result<()> {
6250 encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6251 self.0.encode(encoder, offset + 0, depth)?;
6255 Ok(())
6256 }
6257 }
6258
6259 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6260 for AudioCapturerSetUsage2Request
6261 {
6262 #[inline(always)]
6263 fn new_empty() -> Self {
6264 Self { usage: fidl::new_empty!(AudioCaptureUsage2, D) }
6265 }
6266
6267 #[inline]
6268 unsafe fn decode(
6269 &mut self,
6270 decoder: &mut fidl::encoding::Decoder<'_, D>,
6271 offset: usize,
6272 _depth: fidl::encoding::Depth,
6273 ) -> fidl::Result<()> {
6274 decoder.debug_check_bounds::<Self>(offset);
6275 fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
6277 Ok(())
6278 }
6279 }
6280
6281 impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsageRequest {
6282 type Borrowed<'a> = &'a Self;
6283 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6284 value
6285 }
6286 }
6287
6288 unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsageRequest {
6289 type Owned = Self;
6290
6291 #[inline(always)]
6292 fn inline_align(_context: fidl::encoding::Context) -> usize {
6293 4
6294 }
6295
6296 #[inline(always)]
6297 fn inline_size(_context: fidl::encoding::Context) -> usize {
6298 4
6299 }
6300 }
6301
6302 unsafe impl<D: fidl::encoding::ResourceDialect>
6303 fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for &AudioCapturerSetUsageRequest
6304 {
6305 #[inline]
6306 unsafe fn encode(
6307 self,
6308 encoder: &mut fidl::encoding::Encoder<'_, D>,
6309 offset: usize,
6310 _depth: fidl::encoding::Depth,
6311 ) -> fidl::Result<()> {
6312 encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6313 fidl::encoding::Encode::<AudioCapturerSetUsageRequest, D>::encode(
6315 (<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6316 encoder,
6317 offset,
6318 _depth,
6319 )
6320 }
6321 }
6322 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage, D>>
6323 fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for (T0,)
6324 {
6325 #[inline]
6326 unsafe fn encode(
6327 self,
6328 encoder: &mut fidl::encoding::Encoder<'_, D>,
6329 offset: usize,
6330 depth: fidl::encoding::Depth,
6331 ) -> fidl::Result<()> {
6332 encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6333 self.0.encode(encoder, offset + 0, depth)?;
6337 Ok(())
6338 }
6339 }
6340
6341 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6342 for AudioCapturerSetUsageRequest
6343 {
6344 #[inline(always)]
6345 fn new_empty() -> Self {
6346 Self { usage: fidl::new_empty!(AudioCaptureUsage, D) }
6347 }
6348
6349 #[inline]
6350 unsafe fn decode(
6351 &mut self,
6352 decoder: &mut fidl::encoding::Decoder<'_, D>,
6353 offset: usize,
6354 _depth: fidl::encoding::Depth,
6355 ) -> fidl::Result<()> {
6356 decoder.debug_check_bounds::<Self>(offset);
6357 fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
6359 Ok(())
6360 }
6361 }
6362
6363 impl fidl::encoding::ValueTypeMarker for AudioCapturerStartAsyncCaptureRequest {
6364 type Borrowed<'a> = &'a Self;
6365 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6366 value
6367 }
6368 }
6369
6370 unsafe impl fidl::encoding::TypeMarker for AudioCapturerStartAsyncCaptureRequest {
6371 type Owned = Self;
6372
6373 #[inline(always)]
6374 fn inline_align(_context: fidl::encoding::Context) -> usize {
6375 4
6376 }
6377
6378 #[inline(always)]
6379 fn inline_size(_context: fidl::encoding::Context) -> usize {
6380 4
6381 }
6382 #[inline(always)]
6383 fn encode_is_copy() -> bool {
6384 true
6385 }
6386
6387 #[inline(always)]
6388 fn decode_is_copy() -> bool {
6389 true
6390 }
6391 }
6392
6393 unsafe impl<D: fidl::encoding::ResourceDialect>
6394 fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D>
6395 for &AudioCapturerStartAsyncCaptureRequest
6396 {
6397 #[inline]
6398 unsafe fn encode(
6399 self,
6400 encoder: &mut fidl::encoding::Encoder<'_, D>,
6401 offset: usize,
6402 _depth: fidl::encoding::Depth,
6403 ) -> fidl::Result<()> {
6404 encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6405 unsafe {
6406 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6408 (buf_ptr as *mut AudioCapturerStartAsyncCaptureRequest)
6409 .write_unaligned((self as *const AudioCapturerStartAsyncCaptureRequest).read());
6410 }
6413 Ok(())
6414 }
6415 }
6416 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
6417 fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D> for (T0,)
6418 {
6419 #[inline]
6420 unsafe fn encode(
6421 self,
6422 encoder: &mut fidl::encoding::Encoder<'_, D>,
6423 offset: usize,
6424 depth: fidl::encoding::Depth,
6425 ) -> fidl::Result<()> {
6426 encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6427 self.0.encode(encoder, offset + 0, depth)?;
6431 Ok(())
6432 }
6433 }
6434
6435 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6436 for AudioCapturerStartAsyncCaptureRequest
6437 {
6438 #[inline(always)]
6439 fn new_empty() -> Self {
6440 Self { frames_per_packet: fidl::new_empty!(u32, D) }
6441 }
6442
6443 #[inline]
6444 unsafe fn decode(
6445 &mut self,
6446 decoder: &mut fidl::encoding::Decoder<'_, D>,
6447 offset: usize,
6448 _depth: fidl::encoding::Depth,
6449 ) -> fidl::Result<()> {
6450 decoder.debug_check_bounds::<Self>(offset);
6451 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6452 unsafe {
6455 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
6456 }
6457 Ok(())
6458 }
6459 }
6460
6461 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatAac {
6462 type Borrowed<'a> = &'a Self;
6463 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6464 value
6465 }
6466 }
6467
6468 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatAac {
6469 type Owned = Self;
6470
6471 #[inline(always)]
6472 fn inline_align(_context: fidl::encoding::Context) -> usize {
6473 1
6474 }
6475
6476 #[inline(always)]
6477 fn inline_size(_context: fidl::encoding::Context) -> usize {
6478 1
6479 }
6480 }
6481
6482 unsafe impl<D: fidl::encoding::ResourceDialect>
6483 fidl::encoding::Encode<AudioCompressedFormatAac, D> for &AudioCompressedFormatAac
6484 {
6485 #[inline]
6486 unsafe fn encode(
6487 self,
6488 encoder: &mut fidl::encoding::Encoder<'_, D>,
6489 offset: usize,
6490 _depth: fidl::encoding::Depth,
6491 ) -> fidl::Result<()> {
6492 encoder.debug_check_bounds::<AudioCompressedFormatAac>(offset);
6493 encoder.write_num(0u8, offset);
6494 Ok(())
6495 }
6496 }
6497
6498 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6499 for AudioCompressedFormatAac
6500 {
6501 #[inline(always)]
6502 fn new_empty() -> Self {
6503 Self
6504 }
6505
6506 #[inline]
6507 unsafe fn decode(
6508 &mut self,
6509 decoder: &mut fidl::encoding::Decoder<'_, D>,
6510 offset: usize,
6511 _depth: fidl::encoding::Depth,
6512 ) -> fidl::Result<()> {
6513 decoder.debug_check_bounds::<Self>(offset);
6514 match decoder.read_num::<u8>(offset) {
6515 0 => Ok(()),
6516 _ => Err(fidl::Error::Invalid),
6517 }
6518 }
6519 }
6520
6521 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatSbc {
6522 type Borrowed<'a> = &'a Self;
6523 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6524 value
6525 }
6526 }
6527
6528 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatSbc {
6529 type Owned = Self;
6530
6531 #[inline(always)]
6532 fn inline_align(_context: fidl::encoding::Context) -> usize {
6533 1
6534 }
6535
6536 #[inline(always)]
6537 fn inline_size(_context: fidl::encoding::Context) -> usize {
6538 1
6539 }
6540 }
6541
6542 unsafe impl<D: fidl::encoding::ResourceDialect>
6543 fidl::encoding::Encode<AudioCompressedFormatSbc, D> for &AudioCompressedFormatSbc
6544 {
6545 #[inline]
6546 unsafe fn encode(
6547 self,
6548 encoder: &mut fidl::encoding::Encoder<'_, D>,
6549 offset: usize,
6550 _depth: fidl::encoding::Depth,
6551 ) -> fidl::Result<()> {
6552 encoder.debug_check_bounds::<AudioCompressedFormatSbc>(offset);
6553 encoder.write_num(0u8, offset);
6554 Ok(())
6555 }
6556 }
6557
6558 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6559 for AudioCompressedFormatSbc
6560 {
6561 #[inline(always)]
6562 fn new_empty() -> Self {
6563 Self
6564 }
6565
6566 #[inline]
6567 unsafe fn decode(
6568 &mut self,
6569 decoder: &mut fidl::encoding::Decoder<'_, D>,
6570 offset: usize,
6571 _depth: fidl::encoding::Depth,
6572 ) -> fidl::Result<()> {
6573 decoder.debug_check_bounds::<Self>(offset);
6574 match decoder.read_num::<u8>(offset) {
6575 0 => Ok(()),
6576 _ => Err(fidl::Error::Invalid),
6577 }
6578 }
6579 }
6580
6581 impl fidl::encoding::ValueTypeMarker for AudioConsumerSetRateRequest {
6582 type Borrowed<'a> = &'a Self;
6583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6584 value
6585 }
6586 }
6587
6588 unsafe impl fidl::encoding::TypeMarker for AudioConsumerSetRateRequest {
6589 type Owned = Self;
6590
6591 #[inline(always)]
6592 fn inline_align(_context: fidl::encoding::Context) -> usize {
6593 4
6594 }
6595
6596 #[inline(always)]
6597 fn inline_size(_context: fidl::encoding::Context) -> usize {
6598 4
6599 }
6600 }
6601
6602 unsafe impl<D: fidl::encoding::ResourceDialect>
6603 fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for &AudioConsumerSetRateRequest
6604 {
6605 #[inline]
6606 unsafe fn encode(
6607 self,
6608 encoder: &mut fidl::encoding::Encoder<'_, D>,
6609 offset: usize,
6610 _depth: fidl::encoding::Depth,
6611 ) -> fidl::Result<()> {
6612 encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6613 fidl::encoding::Encode::<AudioConsumerSetRateRequest, D>::encode(
6615 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.rate),),
6616 encoder,
6617 offset,
6618 _depth,
6619 )
6620 }
6621 }
6622 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
6623 fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for (T0,)
6624 {
6625 #[inline]
6626 unsafe fn encode(
6627 self,
6628 encoder: &mut fidl::encoding::Encoder<'_, D>,
6629 offset: usize,
6630 depth: fidl::encoding::Depth,
6631 ) -> fidl::Result<()> {
6632 encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6633 self.0.encode(encoder, offset + 0, depth)?;
6637 Ok(())
6638 }
6639 }
6640
6641 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6642 for AudioConsumerSetRateRequest
6643 {
6644 #[inline(always)]
6645 fn new_empty() -> Self {
6646 Self { rate: fidl::new_empty!(f32, D) }
6647 }
6648
6649 #[inline]
6650 unsafe fn decode(
6651 &mut self,
6652 decoder: &mut fidl::encoding::Decoder<'_, D>,
6653 offset: usize,
6654 _depth: fidl::encoding::Depth,
6655 ) -> fidl::Result<()> {
6656 decoder.debug_check_bounds::<Self>(offset);
6657 fidl::decode!(f32, D, &mut self.rate, decoder, offset + 0, _depth)?;
6659 Ok(())
6660 }
6661 }
6662
6663 impl fidl::encoding::ValueTypeMarker for AudioConsumerStartRequest {
6664 type Borrowed<'a> = &'a Self;
6665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6666 value
6667 }
6668 }
6669
6670 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartRequest {
6671 type Owned = Self;
6672
6673 #[inline(always)]
6674 fn inline_align(_context: fidl::encoding::Context) -> usize {
6675 8
6676 }
6677
6678 #[inline(always)]
6679 fn inline_size(_context: fidl::encoding::Context) -> usize {
6680 24
6681 }
6682 }
6683
6684 unsafe impl<D: fidl::encoding::ResourceDialect>
6685 fidl::encoding::Encode<AudioConsumerStartRequest, D> for &AudioConsumerStartRequest
6686 {
6687 #[inline]
6688 unsafe fn encode(
6689 self,
6690 encoder: &mut fidl::encoding::Encoder<'_, D>,
6691 offset: usize,
6692 _depth: fidl::encoding::Depth,
6693 ) -> fidl::Result<()> {
6694 encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6695 fidl::encoding::Encode::<AudioConsumerStartRequest, D>::encode(
6697 (
6698 <AudioConsumerStartFlags as fidl::encoding::ValueTypeMarker>::borrow(
6699 &self.flags,
6700 ),
6701 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.reference_time),
6702 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.media_time),
6703 ),
6704 encoder,
6705 offset,
6706 _depth,
6707 )
6708 }
6709 }
6710 unsafe impl<
6711 D: fidl::encoding::ResourceDialect,
6712 T0: fidl::encoding::Encode<AudioConsumerStartFlags, D>,
6713 T1: fidl::encoding::Encode<i64, D>,
6714 T2: fidl::encoding::Encode<i64, D>,
6715 > fidl::encoding::Encode<AudioConsumerStartRequest, D> for (T0, T1, T2)
6716 {
6717 #[inline]
6718 unsafe fn encode(
6719 self,
6720 encoder: &mut fidl::encoding::Encoder<'_, D>,
6721 offset: usize,
6722 depth: fidl::encoding::Depth,
6723 ) -> fidl::Result<()> {
6724 encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6725 unsafe {
6728 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6729 (ptr as *mut u64).write_unaligned(0);
6730 }
6731 self.0.encode(encoder, offset + 0, depth)?;
6733 self.1.encode(encoder, offset + 8, depth)?;
6734 self.2.encode(encoder, offset + 16, depth)?;
6735 Ok(())
6736 }
6737 }
6738
6739 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6740 for AudioConsumerStartRequest
6741 {
6742 #[inline(always)]
6743 fn new_empty() -> Self {
6744 Self {
6745 flags: fidl::new_empty!(AudioConsumerStartFlags, D),
6746 reference_time: fidl::new_empty!(i64, D),
6747 media_time: fidl::new_empty!(i64, D),
6748 }
6749 }
6750
6751 #[inline]
6752 unsafe fn decode(
6753 &mut self,
6754 decoder: &mut fidl::encoding::Decoder<'_, D>,
6755 offset: usize,
6756 _depth: fidl::encoding::Depth,
6757 ) -> fidl::Result<()> {
6758 decoder.debug_check_bounds::<Self>(offset);
6759 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
6761 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6762 let mask = 0xffffffff00000000u64;
6763 let maskedval = padval & mask;
6764 if maskedval != 0 {
6765 return Err(fidl::Error::NonZeroPadding {
6766 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
6767 });
6768 }
6769 fidl::decode!(
6770 AudioConsumerStartFlags,
6771 D,
6772 &mut self.flags,
6773 decoder,
6774 offset + 0,
6775 _depth
6776 )?;
6777 fidl::decode!(i64, D, &mut self.reference_time, decoder, offset + 8, _depth)?;
6778 fidl::decode!(i64, D, &mut self.media_time, decoder, offset + 16, _depth)?;
6779 Ok(())
6780 }
6781 }
6782
6783 impl fidl::encoding::ValueTypeMarker for AudioConsumerWatchStatusResponse {
6784 type Borrowed<'a> = &'a Self;
6785 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6786 value
6787 }
6788 }
6789
6790 unsafe impl fidl::encoding::TypeMarker for AudioConsumerWatchStatusResponse {
6791 type Owned = Self;
6792
6793 #[inline(always)]
6794 fn inline_align(_context: fidl::encoding::Context) -> usize {
6795 8
6796 }
6797
6798 #[inline(always)]
6799 fn inline_size(_context: fidl::encoding::Context) -> usize {
6800 16
6801 }
6802 }
6803
6804 unsafe impl<D: fidl::encoding::ResourceDialect>
6805 fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D>
6806 for &AudioConsumerWatchStatusResponse
6807 {
6808 #[inline]
6809 unsafe fn encode(
6810 self,
6811 encoder: &mut fidl::encoding::Encoder<'_, D>,
6812 offset: usize,
6813 _depth: fidl::encoding::Depth,
6814 ) -> fidl::Result<()> {
6815 encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
6816 fidl::encoding::Encode::<AudioConsumerWatchStatusResponse, D>::encode(
6818 (<AudioConsumerStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
6819 encoder,
6820 offset,
6821 _depth,
6822 )
6823 }
6824 }
6825 unsafe impl<
6826 D: fidl::encoding::ResourceDialect,
6827 T0: fidl::encoding::Encode<AudioConsumerStatus, D>,
6828 > fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D> for (T0,)
6829 {
6830 #[inline]
6831 unsafe fn encode(
6832 self,
6833 encoder: &mut fidl::encoding::Encoder<'_, D>,
6834 offset: usize,
6835 depth: fidl::encoding::Depth,
6836 ) -> fidl::Result<()> {
6837 encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
6838 self.0.encode(encoder, offset + 0, depth)?;
6842 Ok(())
6843 }
6844 }
6845
6846 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6847 for AudioConsumerWatchStatusResponse
6848 {
6849 #[inline(always)]
6850 fn new_empty() -> Self {
6851 Self { status: fidl::new_empty!(AudioConsumerStatus, D) }
6852 }
6853
6854 #[inline]
6855 unsafe fn decode(
6856 &mut self,
6857 decoder: &mut fidl::encoding::Decoder<'_, D>,
6858 offset: usize,
6859 _depth: fidl::encoding::Depth,
6860 ) -> fidl::Result<()> {
6861 decoder.debug_check_bounds::<Self>(offset);
6862 fidl::decode!(AudioConsumerStatus, D, &mut self.status, decoder, offset + 0, _depth)?;
6864 Ok(())
6865 }
6866 }
6867
6868 impl fidl::encoding::ValueTypeMarker for AudioCoreEnableDeviceSettingsRequest {
6869 type Borrowed<'a> = &'a Self;
6870 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6871 value
6872 }
6873 }
6874
6875 unsafe impl fidl::encoding::TypeMarker for AudioCoreEnableDeviceSettingsRequest {
6876 type Owned = Self;
6877
6878 #[inline(always)]
6879 fn inline_align(_context: fidl::encoding::Context) -> usize {
6880 1
6881 }
6882
6883 #[inline(always)]
6884 fn inline_size(_context: fidl::encoding::Context) -> usize {
6885 1
6886 }
6887 }
6888
6889 unsafe impl<D: fidl::encoding::ResourceDialect>
6890 fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D>
6891 for &AudioCoreEnableDeviceSettingsRequest
6892 {
6893 #[inline]
6894 unsafe fn encode(
6895 self,
6896 encoder: &mut fidl::encoding::Encoder<'_, D>,
6897 offset: usize,
6898 _depth: fidl::encoding::Depth,
6899 ) -> fidl::Result<()> {
6900 encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
6901 fidl::encoding::Encode::<AudioCoreEnableDeviceSettingsRequest, D>::encode(
6903 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
6904 encoder,
6905 offset,
6906 _depth,
6907 )
6908 }
6909 }
6910 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
6911 fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D> for (T0,)
6912 {
6913 #[inline]
6914 unsafe fn encode(
6915 self,
6916 encoder: &mut fidl::encoding::Encoder<'_, D>,
6917 offset: usize,
6918 depth: fidl::encoding::Depth,
6919 ) -> fidl::Result<()> {
6920 encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
6921 self.0.encode(encoder, offset + 0, depth)?;
6925 Ok(())
6926 }
6927 }
6928
6929 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6930 for AudioCoreEnableDeviceSettingsRequest
6931 {
6932 #[inline(always)]
6933 fn new_empty() -> Self {
6934 Self { enabled: fidl::new_empty!(bool, D) }
6935 }
6936
6937 #[inline]
6938 unsafe fn decode(
6939 &mut self,
6940 decoder: &mut fidl::encoding::Decoder<'_, D>,
6941 offset: usize,
6942 _depth: fidl::encoding::Depth,
6943 ) -> fidl::Result<()> {
6944 decoder.debug_check_bounds::<Self>(offset);
6945 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
6947 Ok(())
6948 }
6949 }
6950
6951 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Request {
6952 type Borrowed<'a> = &'a Self;
6953 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6954 value
6955 }
6956 }
6957
6958 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Request {
6959 type Owned = Self;
6960
6961 #[inline(always)]
6962 fn inline_align(_context: fidl::encoding::Context) -> usize {
6963 8
6964 }
6965
6966 #[inline(always)]
6967 fn inline_size(_context: fidl::encoding::Context) -> usize {
6968 24
6969 }
6970 }
6971
6972 unsafe impl<D: fidl::encoding::ResourceDialect>
6973 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D>
6974 for &AudioCoreGetDbFromVolume2Request
6975 {
6976 #[inline]
6977 unsafe fn encode(
6978 self,
6979 encoder: &mut fidl::encoding::Encoder<'_, D>,
6980 offset: usize,
6981 _depth: fidl::encoding::Depth,
6982 ) -> fidl::Result<()> {
6983 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
6984 fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Request, D>::encode(
6986 (
6987 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
6988 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
6989 ),
6990 encoder,
6991 offset,
6992 _depth,
6993 )
6994 }
6995 }
6996 unsafe impl<
6997 D: fidl::encoding::ResourceDialect,
6998 T0: fidl::encoding::Encode<Usage2, D>,
6999 T1: fidl::encoding::Encode<f32, D>,
7000 > fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D> for (T0, T1)
7001 {
7002 #[inline]
7003 unsafe fn encode(
7004 self,
7005 encoder: &mut fidl::encoding::Encoder<'_, D>,
7006 offset: usize,
7007 depth: fidl::encoding::Depth,
7008 ) -> fidl::Result<()> {
7009 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
7010 unsafe {
7013 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7014 (ptr as *mut u64).write_unaligned(0);
7015 }
7016 self.0.encode(encoder, offset + 0, depth)?;
7018 self.1.encode(encoder, offset + 16, depth)?;
7019 Ok(())
7020 }
7021 }
7022
7023 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7024 for AudioCoreGetDbFromVolume2Request
7025 {
7026 #[inline(always)]
7027 fn new_empty() -> Self {
7028 Self { usage: fidl::new_empty!(Usage2, D), volume: fidl::new_empty!(f32, D) }
7029 }
7030
7031 #[inline]
7032 unsafe fn decode(
7033 &mut self,
7034 decoder: &mut fidl::encoding::Decoder<'_, D>,
7035 offset: usize,
7036 _depth: fidl::encoding::Depth,
7037 ) -> fidl::Result<()> {
7038 decoder.debug_check_bounds::<Self>(offset);
7039 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7041 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7042 let mask = 0xffffffff00000000u64;
7043 let maskedval = padval & mask;
7044 if maskedval != 0 {
7045 return Err(fidl::Error::NonZeroPadding {
7046 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7047 });
7048 }
7049 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7050 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7051 Ok(())
7052 }
7053 }
7054
7055 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeRequest {
7056 type Borrowed<'a> = &'a Self;
7057 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7058 value
7059 }
7060 }
7061
7062 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeRequest {
7063 type Owned = Self;
7064
7065 #[inline(always)]
7066 fn inline_align(_context: fidl::encoding::Context) -> usize {
7067 8
7068 }
7069
7070 #[inline(always)]
7071 fn inline_size(_context: fidl::encoding::Context) -> usize {
7072 24
7073 }
7074 }
7075
7076 unsafe impl<D: fidl::encoding::ResourceDialect>
7077 fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D>
7078 for &AudioCoreGetDbFromVolumeRequest
7079 {
7080 #[inline]
7081 unsafe fn encode(
7082 self,
7083 encoder: &mut fidl::encoding::Encoder<'_, D>,
7084 offset: usize,
7085 _depth: fidl::encoding::Depth,
7086 ) -> fidl::Result<()> {
7087 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeRequest>(offset);
7088 fidl::encoding::Encode::<AudioCoreGetDbFromVolumeRequest, D>::encode(
7090 (
7091 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7092 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
7093 ),
7094 encoder,
7095 offset,
7096 _depth,
7097 )
7098 }
7099 }
7100 unsafe impl<
7101 D: fidl::encoding::ResourceDialect,
7102 T0: fidl::encoding::Encode<Usage, D>,
7103 T1: fidl::encoding::Encode<f32, D>,
7104 > fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D> for (T0, T1)
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::<AudioCoreGetDbFromVolumeRequest>(offset);
7114 unsafe {
7117 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7118 (ptr as *mut u64).write_unaligned(0);
7119 }
7120 self.0.encode(encoder, offset + 0, depth)?;
7122 self.1.encode(encoder, offset + 16, depth)?;
7123 Ok(())
7124 }
7125 }
7126
7127 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7128 for AudioCoreGetDbFromVolumeRequest
7129 {
7130 #[inline(always)]
7131 fn new_empty() -> Self {
7132 Self { usage: fidl::new_empty!(Usage, D), volume: fidl::new_empty!(f32, D) }
7133 }
7134
7135 #[inline]
7136 unsafe fn decode(
7137 &mut self,
7138 decoder: &mut fidl::encoding::Decoder<'_, D>,
7139 offset: usize,
7140 _depth: fidl::encoding::Depth,
7141 ) -> fidl::Result<()> {
7142 decoder.debug_check_bounds::<Self>(offset);
7143 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7145 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7146 let mask = 0xffffffff00000000u64;
7147 let maskedval = padval & mask;
7148 if maskedval != 0 {
7149 return Err(fidl::Error::NonZeroPadding {
7150 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7151 });
7152 }
7153 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7154 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7155 Ok(())
7156 }
7157 }
7158
7159 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeResponse {
7160 type Borrowed<'a> = &'a Self;
7161 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7162 value
7163 }
7164 }
7165
7166 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeResponse {
7167 type Owned = Self;
7168
7169 #[inline(always)]
7170 fn inline_align(_context: fidl::encoding::Context) -> usize {
7171 4
7172 }
7173
7174 #[inline(always)]
7175 fn inline_size(_context: fidl::encoding::Context) -> usize {
7176 4
7177 }
7178 }
7179
7180 unsafe impl<D: fidl::encoding::ResourceDialect>
7181 fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D>
7182 for &AudioCoreGetDbFromVolumeResponse
7183 {
7184 #[inline]
7185 unsafe fn encode(
7186 self,
7187 encoder: &mut fidl::encoding::Encoder<'_, D>,
7188 offset: usize,
7189 _depth: fidl::encoding::Depth,
7190 ) -> fidl::Result<()> {
7191 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7192 fidl::encoding::Encode::<AudioCoreGetDbFromVolumeResponse, D>::encode(
7194 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
7195 encoder,
7196 offset,
7197 _depth,
7198 )
7199 }
7200 }
7201 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7202 fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D> for (T0,)
7203 {
7204 #[inline]
7205 unsafe fn encode(
7206 self,
7207 encoder: &mut fidl::encoding::Encoder<'_, D>,
7208 offset: usize,
7209 depth: fidl::encoding::Depth,
7210 ) -> fidl::Result<()> {
7211 encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7212 self.0.encode(encoder, offset + 0, depth)?;
7216 Ok(())
7217 }
7218 }
7219
7220 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7221 for AudioCoreGetDbFromVolumeResponse
7222 {
7223 #[inline(always)]
7224 fn new_empty() -> Self {
7225 Self { gain_db: fidl::new_empty!(f32, D) }
7226 }
7227
7228 #[inline]
7229 unsafe fn decode(
7230 &mut self,
7231 decoder: &mut fidl::encoding::Decoder<'_, D>,
7232 offset: usize,
7233 _depth: fidl::encoding::Depth,
7234 ) -> fidl::Result<()> {
7235 decoder.debug_check_bounds::<Self>(offset);
7236 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
7238 Ok(())
7239 }
7240 }
7241
7242 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Request {
7243 type Borrowed<'a> = &'a Self;
7244 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7245 value
7246 }
7247 }
7248
7249 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Request {
7250 type Owned = Self;
7251
7252 #[inline(always)]
7253 fn inline_align(_context: fidl::encoding::Context) -> usize {
7254 8
7255 }
7256
7257 #[inline(always)]
7258 fn inline_size(_context: fidl::encoding::Context) -> usize {
7259 24
7260 }
7261 }
7262
7263 unsafe impl<D: fidl::encoding::ResourceDialect>
7264 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D>
7265 for &AudioCoreGetVolumeFromDb2Request
7266 {
7267 #[inline]
7268 unsafe fn encode(
7269 self,
7270 encoder: &mut fidl::encoding::Encoder<'_, D>,
7271 offset: usize,
7272 _depth: fidl::encoding::Depth,
7273 ) -> fidl::Result<()> {
7274 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7275 fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Request, D>::encode(
7277 (
7278 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7279 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7280 ),
7281 encoder,
7282 offset,
7283 _depth,
7284 )
7285 }
7286 }
7287 unsafe impl<
7288 D: fidl::encoding::ResourceDialect,
7289 T0: fidl::encoding::Encode<Usage2, D>,
7290 T1: fidl::encoding::Encode<f32, D>,
7291 > fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D> for (T0, T1)
7292 {
7293 #[inline]
7294 unsafe fn encode(
7295 self,
7296 encoder: &mut fidl::encoding::Encoder<'_, D>,
7297 offset: usize,
7298 depth: fidl::encoding::Depth,
7299 ) -> fidl::Result<()> {
7300 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7301 unsafe {
7304 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7305 (ptr as *mut u64).write_unaligned(0);
7306 }
7307 self.0.encode(encoder, offset + 0, depth)?;
7309 self.1.encode(encoder, offset + 16, depth)?;
7310 Ok(())
7311 }
7312 }
7313
7314 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7315 for AudioCoreGetVolumeFromDb2Request
7316 {
7317 #[inline(always)]
7318 fn new_empty() -> Self {
7319 Self { usage: fidl::new_empty!(Usage2, D), gain_db: fidl::new_empty!(f32, D) }
7320 }
7321
7322 #[inline]
7323 unsafe fn decode(
7324 &mut self,
7325 decoder: &mut fidl::encoding::Decoder<'_, D>,
7326 offset: usize,
7327 _depth: fidl::encoding::Depth,
7328 ) -> fidl::Result<()> {
7329 decoder.debug_check_bounds::<Self>(offset);
7330 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7332 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7333 let mask = 0xffffffff00000000u64;
7334 let maskedval = padval & mask;
7335 if maskedval != 0 {
7336 return Err(fidl::Error::NonZeroPadding {
7337 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7338 });
7339 }
7340 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7341 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7342 Ok(())
7343 }
7344 }
7345
7346 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbRequest {
7347 type Borrowed<'a> = &'a Self;
7348 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7349 value
7350 }
7351 }
7352
7353 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbRequest {
7354 type Owned = Self;
7355
7356 #[inline(always)]
7357 fn inline_align(_context: fidl::encoding::Context) -> usize {
7358 8
7359 }
7360
7361 #[inline(always)]
7362 fn inline_size(_context: fidl::encoding::Context) -> usize {
7363 24
7364 }
7365 }
7366
7367 unsafe impl<D: fidl::encoding::ResourceDialect>
7368 fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D>
7369 for &AudioCoreGetVolumeFromDbRequest
7370 {
7371 #[inline]
7372 unsafe fn encode(
7373 self,
7374 encoder: &mut fidl::encoding::Encoder<'_, D>,
7375 offset: usize,
7376 _depth: fidl::encoding::Depth,
7377 ) -> fidl::Result<()> {
7378 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbRequest>(offset);
7379 fidl::encoding::Encode::<AudioCoreGetVolumeFromDbRequest, D>::encode(
7381 (
7382 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7383 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7384 ),
7385 encoder,
7386 offset,
7387 _depth,
7388 )
7389 }
7390 }
7391 unsafe impl<
7392 D: fidl::encoding::ResourceDialect,
7393 T0: fidl::encoding::Encode<Usage, D>,
7394 T1: fidl::encoding::Encode<f32, D>,
7395 > fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D> for (T0, T1)
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::<AudioCoreGetVolumeFromDbRequest>(offset);
7405 unsafe {
7408 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7409 (ptr as *mut u64).write_unaligned(0);
7410 }
7411 self.0.encode(encoder, offset + 0, depth)?;
7413 self.1.encode(encoder, offset + 16, depth)?;
7414 Ok(())
7415 }
7416 }
7417
7418 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7419 for AudioCoreGetVolumeFromDbRequest
7420 {
7421 #[inline(always)]
7422 fn new_empty() -> Self {
7423 Self { usage: fidl::new_empty!(Usage, D), gain_db: fidl::new_empty!(f32, D) }
7424 }
7425
7426 #[inline]
7427 unsafe fn decode(
7428 &mut self,
7429 decoder: &mut fidl::encoding::Decoder<'_, D>,
7430 offset: usize,
7431 _depth: fidl::encoding::Depth,
7432 ) -> fidl::Result<()> {
7433 decoder.debug_check_bounds::<Self>(offset);
7434 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7436 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7437 let mask = 0xffffffff00000000u64;
7438 let maskedval = padval & mask;
7439 if maskedval != 0 {
7440 return Err(fidl::Error::NonZeroPadding {
7441 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7442 });
7443 }
7444 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7445 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7446 Ok(())
7447 }
7448 }
7449
7450 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbResponse {
7451 type Borrowed<'a> = &'a Self;
7452 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7453 value
7454 }
7455 }
7456
7457 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbResponse {
7458 type Owned = Self;
7459
7460 #[inline(always)]
7461 fn inline_align(_context: fidl::encoding::Context) -> usize {
7462 4
7463 }
7464
7465 #[inline(always)]
7466 fn inline_size(_context: fidl::encoding::Context) -> usize {
7467 4
7468 }
7469 }
7470
7471 unsafe impl<D: fidl::encoding::ResourceDialect>
7472 fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D>
7473 for &AudioCoreGetVolumeFromDbResponse
7474 {
7475 #[inline]
7476 unsafe fn encode(
7477 self,
7478 encoder: &mut fidl::encoding::Encoder<'_, D>,
7479 offset: usize,
7480 _depth: fidl::encoding::Depth,
7481 ) -> fidl::Result<()> {
7482 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7483 fidl::encoding::Encode::<AudioCoreGetVolumeFromDbResponse, D>::encode(
7485 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
7486 encoder,
7487 offset,
7488 _depth,
7489 )
7490 }
7491 }
7492 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7493 fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D> for (T0,)
7494 {
7495 #[inline]
7496 unsafe fn encode(
7497 self,
7498 encoder: &mut fidl::encoding::Encoder<'_, D>,
7499 offset: usize,
7500 depth: fidl::encoding::Depth,
7501 ) -> fidl::Result<()> {
7502 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7503 self.0.encode(encoder, offset + 0, depth)?;
7507 Ok(())
7508 }
7509 }
7510
7511 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7512 for AudioCoreGetVolumeFromDbResponse
7513 {
7514 #[inline(always)]
7515 fn new_empty() -> Self {
7516 Self { volume: fidl::new_empty!(f32, D) }
7517 }
7518
7519 #[inline]
7520 unsafe fn decode(
7521 &mut self,
7522 decoder: &mut fidl::encoding::Decoder<'_, D>,
7523 offset: usize,
7524 _depth: fidl::encoding::Depth,
7525 ) -> fidl::Result<()> {
7526 decoder.debug_check_bounds::<Self>(offset);
7527 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
7529 Ok(())
7530 }
7531 }
7532
7533 impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGain2Request {
7534 type Borrowed<'a> = &'a Self;
7535 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7536 value
7537 }
7538 }
7539
7540 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGain2Request {
7541 type Owned = Self;
7542
7543 #[inline(always)]
7544 fn inline_align(_context: fidl::encoding::Context) -> usize {
7545 4
7546 }
7547
7548 #[inline(always)]
7549 fn inline_size(_context: fidl::encoding::Context) -> usize {
7550 8
7551 }
7552 }
7553
7554 unsafe impl<D: fidl::encoding::ResourceDialect>
7555 fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D>
7556 for &AudioCoreSetCaptureUsageGain2Request
7557 {
7558 #[inline]
7559 unsafe fn encode(
7560 self,
7561 encoder: &mut fidl::encoding::Encoder<'_, D>,
7562 offset: usize,
7563 _depth: fidl::encoding::Depth,
7564 ) -> fidl::Result<()> {
7565 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7566 fidl::encoding::Encode::<AudioCoreSetCaptureUsageGain2Request, D>::encode(
7568 (
7569 <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7570 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7571 ),
7572 encoder,
7573 offset,
7574 _depth,
7575 )
7576 }
7577 }
7578 unsafe impl<
7579 D: fidl::encoding::ResourceDialect,
7580 T0: fidl::encoding::Encode<AudioCaptureUsage2, D>,
7581 T1: fidl::encoding::Encode<f32, D>,
7582 > fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D> for (T0, T1)
7583 {
7584 #[inline]
7585 unsafe fn encode(
7586 self,
7587 encoder: &mut fidl::encoding::Encoder<'_, D>,
7588 offset: usize,
7589 depth: fidl::encoding::Depth,
7590 ) -> fidl::Result<()> {
7591 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7592 self.0.encode(encoder, offset + 0, depth)?;
7596 self.1.encode(encoder, offset + 4, depth)?;
7597 Ok(())
7598 }
7599 }
7600
7601 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7602 for AudioCoreSetCaptureUsageGain2Request
7603 {
7604 #[inline(always)]
7605 fn new_empty() -> Self {
7606 Self {
7607 usage: fidl::new_empty!(AudioCaptureUsage2, D),
7608 gain_db: fidl::new_empty!(f32, D),
7609 }
7610 }
7611
7612 #[inline]
7613 unsafe fn decode(
7614 &mut self,
7615 decoder: &mut fidl::encoding::Decoder<'_, D>,
7616 offset: usize,
7617 _depth: fidl::encoding::Depth,
7618 ) -> fidl::Result<()> {
7619 decoder.debug_check_bounds::<Self>(offset);
7620 fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7622 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7623 Ok(())
7624 }
7625 }
7626
7627 impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGainRequest {
7628 type Borrowed<'a> = &'a Self;
7629 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7630 value
7631 }
7632 }
7633
7634 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGainRequest {
7635 type Owned = Self;
7636
7637 #[inline(always)]
7638 fn inline_align(_context: fidl::encoding::Context) -> usize {
7639 4
7640 }
7641
7642 #[inline(always)]
7643 fn inline_size(_context: fidl::encoding::Context) -> usize {
7644 8
7645 }
7646 }
7647
7648 unsafe impl<D: fidl::encoding::ResourceDialect>
7649 fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D>
7650 for &AudioCoreSetCaptureUsageGainRequest
7651 {
7652 #[inline]
7653 unsafe fn encode(
7654 self,
7655 encoder: &mut fidl::encoding::Encoder<'_, D>,
7656 offset: usize,
7657 _depth: fidl::encoding::Depth,
7658 ) -> fidl::Result<()> {
7659 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7660 fidl::encoding::Encode::<AudioCoreSetCaptureUsageGainRequest, D>::encode(
7662 (
7663 <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7664 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7665 ),
7666 encoder,
7667 offset,
7668 _depth,
7669 )
7670 }
7671 }
7672 unsafe impl<
7673 D: fidl::encoding::ResourceDialect,
7674 T0: fidl::encoding::Encode<AudioCaptureUsage, D>,
7675 T1: fidl::encoding::Encode<f32, D>,
7676 > fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D> for (T0, T1)
7677 {
7678 #[inline]
7679 unsafe fn encode(
7680 self,
7681 encoder: &mut fidl::encoding::Encoder<'_, D>,
7682 offset: usize,
7683 depth: fidl::encoding::Depth,
7684 ) -> fidl::Result<()> {
7685 encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7686 self.0.encode(encoder, offset + 0, depth)?;
7690 self.1.encode(encoder, offset + 4, depth)?;
7691 Ok(())
7692 }
7693 }
7694
7695 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7696 for AudioCoreSetCaptureUsageGainRequest
7697 {
7698 #[inline(always)]
7699 fn new_empty() -> Self {
7700 Self {
7701 usage: fidl::new_empty!(AudioCaptureUsage, D),
7702 gain_db: fidl::new_empty!(f32, D),
7703 }
7704 }
7705
7706 #[inline]
7707 unsafe fn decode(
7708 &mut self,
7709 decoder: &mut fidl::encoding::Decoder<'_, D>,
7710 offset: usize,
7711 _depth: fidl::encoding::Depth,
7712 ) -> fidl::Result<()> {
7713 decoder.debug_check_bounds::<Self>(offset);
7714 fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7716 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7717 Ok(())
7718 }
7719 }
7720
7721 impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteraction2Request {
7722 type Borrowed<'a> = &'a Self;
7723 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7724 value
7725 }
7726 }
7727
7728 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteraction2Request {
7729 type Owned = Self;
7730
7731 #[inline(always)]
7732 fn inline_align(_context: fidl::encoding::Context) -> usize {
7733 8
7734 }
7735
7736 #[inline(always)]
7737 fn inline_size(_context: fidl::encoding::Context) -> usize {
7738 40
7739 }
7740 }
7741
7742 unsafe impl<D: fidl::encoding::ResourceDialect>
7743 fidl::encoding::Encode<AudioCoreSetInteraction2Request, D>
7744 for &AudioCoreSetInteraction2Request
7745 {
7746 #[inline]
7747 unsafe fn encode(
7748 self,
7749 encoder: &mut fidl::encoding::Encoder<'_, D>,
7750 offset: usize,
7751 _depth: fidl::encoding::Depth,
7752 ) -> fidl::Result<()> {
7753 encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7754 fidl::encoding::Encode::<AudioCoreSetInteraction2Request, D>::encode(
7756 (
7757 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
7758 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
7759 <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
7760 ),
7761 encoder,
7762 offset,
7763 _depth,
7764 )
7765 }
7766 }
7767 unsafe impl<
7768 D: fidl::encoding::ResourceDialect,
7769 T0: fidl::encoding::Encode<Usage2, D>,
7770 T1: fidl::encoding::Encode<Usage2, D>,
7771 T2: fidl::encoding::Encode<Behavior, D>,
7772 > fidl::encoding::Encode<AudioCoreSetInteraction2Request, D> for (T0, T1, T2)
7773 {
7774 #[inline]
7775 unsafe fn encode(
7776 self,
7777 encoder: &mut fidl::encoding::Encoder<'_, D>,
7778 offset: usize,
7779 depth: fidl::encoding::Depth,
7780 ) -> fidl::Result<()> {
7781 encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7782 unsafe {
7785 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7786 (ptr as *mut u64).write_unaligned(0);
7787 }
7788 self.0.encode(encoder, offset + 0, depth)?;
7790 self.1.encode(encoder, offset + 16, depth)?;
7791 self.2.encode(encoder, offset + 32, depth)?;
7792 Ok(())
7793 }
7794 }
7795
7796 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7797 for AudioCoreSetInteraction2Request
7798 {
7799 #[inline(always)]
7800 fn new_empty() -> Self {
7801 Self {
7802 active: fidl::new_empty!(Usage2, D),
7803 affected: fidl::new_empty!(Usage2, D),
7804 behavior: fidl::new_empty!(Behavior, D),
7805 }
7806 }
7807
7808 #[inline]
7809 unsafe fn decode(
7810 &mut self,
7811 decoder: &mut fidl::encoding::Decoder<'_, D>,
7812 offset: usize,
7813 _depth: fidl::encoding::Depth,
7814 ) -> fidl::Result<()> {
7815 decoder.debug_check_bounds::<Self>(offset);
7816 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
7818 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7819 let mask = 0xffffffff00000000u64;
7820 let maskedval = padval & mask;
7821 if maskedval != 0 {
7822 return Err(fidl::Error::NonZeroPadding {
7823 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
7824 });
7825 }
7826 fidl::decode!(Usage2, D, &mut self.active, decoder, offset + 0, _depth)?;
7827 fidl::decode!(Usage2, D, &mut self.affected, decoder, offset + 16, _depth)?;
7828 fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
7829 Ok(())
7830 }
7831 }
7832
7833 impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteractionRequest {
7834 type Borrowed<'a> = &'a Self;
7835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7836 value
7837 }
7838 }
7839
7840 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteractionRequest {
7841 type Owned = Self;
7842
7843 #[inline(always)]
7844 fn inline_align(_context: fidl::encoding::Context) -> usize {
7845 8
7846 }
7847
7848 #[inline(always)]
7849 fn inline_size(_context: fidl::encoding::Context) -> usize {
7850 40
7851 }
7852 }
7853
7854 unsafe impl<D: fidl::encoding::ResourceDialect>
7855 fidl::encoding::Encode<AudioCoreSetInteractionRequest, D>
7856 for &AudioCoreSetInteractionRequest
7857 {
7858 #[inline]
7859 unsafe fn encode(
7860 self,
7861 encoder: &mut fidl::encoding::Encoder<'_, D>,
7862 offset: usize,
7863 _depth: fidl::encoding::Depth,
7864 ) -> fidl::Result<()> {
7865 encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
7866 fidl::encoding::Encode::<AudioCoreSetInteractionRequest, D>::encode(
7868 (
7869 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
7870 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
7871 <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
7872 ),
7873 encoder,
7874 offset,
7875 _depth,
7876 )
7877 }
7878 }
7879 unsafe impl<
7880 D: fidl::encoding::ResourceDialect,
7881 T0: fidl::encoding::Encode<Usage, D>,
7882 T1: fidl::encoding::Encode<Usage, D>,
7883 T2: fidl::encoding::Encode<Behavior, D>,
7884 > fidl::encoding::Encode<AudioCoreSetInteractionRequest, D> for (T0, T1, T2)
7885 {
7886 #[inline]
7887 unsafe fn encode(
7888 self,
7889 encoder: &mut fidl::encoding::Encoder<'_, D>,
7890 offset: usize,
7891 depth: fidl::encoding::Depth,
7892 ) -> fidl::Result<()> {
7893 encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
7894 unsafe {
7897 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7898 (ptr as *mut u64).write_unaligned(0);
7899 }
7900 self.0.encode(encoder, offset + 0, depth)?;
7902 self.1.encode(encoder, offset + 16, depth)?;
7903 self.2.encode(encoder, offset + 32, depth)?;
7904 Ok(())
7905 }
7906 }
7907
7908 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7909 for AudioCoreSetInteractionRequest
7910 {
7911 #[inline(always)]
7912 fn new_empty() -> Self {
7913 Self {
7914 active: fidl::new_empty!(Usage, D),
7915 affected: fidl::new_empty!(Usage, D),
7916 behavior: fidl::new_empty!(Behavior, D),
7917 }
7918 }
7919
7920 #[inline]
7921 unsafe fn decode(
7922 &mut self,
7923 decoder: &mut fidl::encoding::Decoder<'_, D>,
7924 offset: usize,
7925 _depth: fidl::encoding::Depth,
7926 ) -> fidl::Result<()> {
7927 decoder.debug_check_bounds::<Self>(offset);
7928 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
7930 let padval = unsafe { (ptr as *const u64).read_unaligned() };
7931 let mask = 0xffffffff00000000u64;
7932 let maskedval = padval & mask;
7933 if maskedval != 0 {
7934 return Err(fidl::Error::NonZeroPadding {
7935 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
7936 });
7937 }
7938 fidl::decode!(Usage, D, &mut self.active, decoder, offset + 0, _depth)?;
7939 fidl::decode!(Usage, D, &mut self.affected, decoder, offset + 16, _depth)?;
7940 fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
7941 Ok(())
7942 }
7943 }
7944
7945 impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGain2Request {
7946 type Borrowed<'a> = &'a Self;
7947 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7948 value
7949 }
7950 }
7951
7952 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGain2Request {
7953 type Owned = Self;
7954
7955 #[inline(always)]
7956 fn inline_align(_context: fidl::encoding::Context) -> usize {
7957 4
7958 }
7959
7960 #[inline(always)]
7961 fn inline_size(_context: fidl::encoding::Context) -> usize {
7962 8
7963 }
7964 }
7965
7966 unsafe impl<D: fidl::encoding::ResourceDialect>
7967 fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D>
7968 for &AudioCoreSetRenderUsageGain2Request
7969 {
7970 #[inline]
7971 unsafe fn encode(
7972 self,
7973 encoder: &mut fidl::encoding::Encoder<'_, D>,
7974 offset: usize,
7975 _depth: fidl::encoding::Depth,
7976 ) -> fidl::Result<()> {
7977 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
7978 fidl::encoding::Encode::<AudioCoreSetRenderUsageGain2Request, D>::encode(
7980 (
7981 <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7982 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7983 ),
7984 encoder,
7985 offset,
7986 _depth,
7987 )
7988 }
7989 }
7990 unsafe impl<
7991 D: fidl::encoding::ResourceDialect,
7992 T0: fidl::encoding::Encode<AudioRenderUsage2, D>,
7993 T1: fidl::encoding::Encode<f32, D>,
7994 > fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D> for (T0, T1)
7995 {
7996 #[inline]
7997 unsafe fn encode(
7998 self,
7999 encoder: &mut fidl::encoding::Encoder<'_, D>,
8000 offset: usize,
8001 depth: fidl::encoding::Depth,
8002 ) -> fidl::Result<()> {
8003 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
8004 self.0.encode(encoder, offset + 0, depth)?;
8008 self.1.encode(encoder, offset + 4, depth)?;
8009 Ok(())
8010 }
8011 }
8012
8013 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8014 for AudioCoreSetRenderUsageGain2Request
8015 {
8016 #[inline(always)]
8017 fn new_empty() -> Self {
8018 Self {
8019 usage: fidl::new_empty!(AudioRenderUsage2, D),
8020 gain_db: fidl::new_empty!(f32, D),
8021 }
8022 }
8023
8024 #[inline]
8025 unsafe fn decode(
8026 &mut self,
8027 decoder: &mut fidl::encoding::Decoder<'_, D>,
8028 offset: usize,
8029 _depth: fidl::encoding::Depth,
8030 ) -> fidl::Result<()> {
8031 decoder.debug_check_bounds::<Self>(offset);
8032 fidl::decode!(AudioRenderUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
8034 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8035 Ok(())
8036 }
8037 }
8038
8039 impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGainRequest {
8040 type Borrowed<'a> = &'a Self;
8041 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8042 value
8043 }
8044 }
8045
8046 unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGainRequest {
8047 type Owned = Self;
8048
8049 #[inline(always)]
8050 fn inline_align(_context: fidl::encoding::Context) -> usize {
8051 4
8052 }
8053
8054 #[inline(always)]
8055 fn inline_size(_context: fidl::encoding::Context) -> usize {
8056 8
8057 }
8058 }
8059
8060 unsafe impl<D: fidl::encoding::ResourceDialect>
8061 fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D>
8062 for &AudioCoreSetRenderUsageGainRequest
8063 {
8064 #[inline]
8065 unsafe fn encode(
8066 self,
8067 encoder: &mut fidl::encoding::Encoder<'_, D>,
8068 offset: usize,
8069 _depth: fidl::encoding::Depth,
8070 ) -> fidl::Result<()> {
8071 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8072 fidl::encoding::Encode::<AudioCoreSetRenderUsageGainRequest, D>::encode(
8074 (
8075 <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
8076 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
8077 ),
8078 encoder,
8079 offset,
8080 _depth,
8081 )
8082 }
8083 }
8084 unsafe impl<
8085 D: fidl::encoding::ResourceDialect,
8086 T0: fidl::encoding::Encode<AudioRenderUsage, D>,
8087 T1: fidl::encoding::Encode<f32, D>,
8088 > fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D> for (T0, T1)
8089 {
8090 #[inline]
8091 unsafe fn encode(
8092 self,
8093 encoder: &mut fidl::encoding::Encoder<'_, D>,
8094 offset: usize,
8095 depth: fidl::encoding::Depth,
8096 ) -> fidl::Result<()> {
8097 encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8098 self.0.encode(encoder, offset + 0, depth)?;
8102 self.1.encode(encoder, offset + 4, depth)?;
8103 Ok(())
8104 }
8105 }
8106
8107 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8108 for AudioCoreSetRenderUsageGainRequest
8109 {
8110 #[inline(always)]
8111 fn new_empty() -> Self {
8112 Self { usage: fidl::new_empty!(AudioRenderUsage, D), gain_db: fidl::new_empty!(f32, D) }
8113 }
8114
8115 #[inline]
8116 unsafe fn decode(
8117 &mut self,
8118 decoder: &mut fidl::encoding::Decoder<'_, D>,
8119 offset: usize,
8120 _depth: fidl::encoding::Depth,
8121 ) -> fidl::Result<()> {
8122 decoder.debug_check_bounds::<Self>(offset);
8123 fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
8125 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8126 Ok(())
8127 }
8128 }
8129
8130 impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Response {
8131 type Borrowed<'a> = &'a Self;
8132 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8133 value
8134 }
8135 }
8136
8137 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Response {
8138 type Owned = Self;
8139
8140 #[inline(always)]
8141 fn inline_align(_context: fidl::encoding::Context) -> usize {
8142 4
8143 }
8144
8145 #[inline(always)]
8146 fn inline_size(_context: fidl::encoding::Context) -> usize {
8147 4
8148 }
8149 }
8150
8151 unsafe impl<D: fidl::encoding::ResourceDialect>
8152 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D>
8153 for &AudioCoreGetDbFromVolume2Response
8154 {
8155 #[inline]
8156 unsafe fn encode(
8157 self,
8158 encoder: &mut fidl::encoding::Encoder<'_, D>,
8159 offset: usize,
8160 _depth: fidl::encoding::Depth,
8161 ) -> fidl::Result<()> {
8162 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8163 fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Response, D>::encode(
8165 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
8166 encoder,
8167 offset,
8168 _depth,
8169 )
8170 }
8171 }
8172 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8173 fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D> for (T0,)
8174 {
8175 #[inline]
8176 unsafe fn encode(
8177 self,
8178 encoder: &mut fidl::encoding::Encoder<'_, D>,
8179 offset: usize,
8180 depth: fidl::encoding::Depth,
8181 ) -> fidl::Result<()> {
8182 encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8183 self.0.encode(encoder, offset + 0, depth)?;
8187 Ok(())
8188 }
8189 }
8190
8191 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8192 for AudioCoreGetDbFromVolume2Response
8193 {
8194 #[inline(always)]
8195 fn new_empty() -> Self {
8196 Self { gain_db: fidl::new_empty!(f32, D) }
8197 }
8198
8199 #[inline]
8200 unsafe fn decode(
8201 &mut self,
8202 decoder: &mut fidl::encoding::Decoder<'_, D>,
8203 offset: usize,
8204 _depth: fidl::encoding::Depth,
8205 ) -> fidl::Result<()> {
8206 decoder.debug_check_bounds::<Self>(offset);
8207 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
8209 Ok(())
8210 }
8211 }
8212
8213 impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Response {
8214 type Borrowed<'a> = &'a Self;
8215 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8216 value
8217 }
8218 }
8219
8220 unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Response {
8221 type Owned = Self;
8222
8223 #[inline(always)]
8224 fn inline_align(_context: fidl::encoding::Context) -> usize {
8225 4
8226 }
8227
8228 #[inline(always)]
8229 fn inline_size(_context: fidl::encoding::Context) -> usize {
8230 4
8231 }
8232 }
8233
8234 unsafe impl<D: fidl::encoding::ResourceDialect>
8235 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D>
8236 for &AudioCoreGetVolumeFromDb2Response
8237 {
8238 #[inline]
8239 unsafe fn encode(
8240 self,
8241 encoder: &mut fidl::encoding::Encoder<'_, D>,
8242 offset: usize,
8243 _depth: fidl::encoding::Depth,
8244 ) -> fidl::Result<()> {
8245 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8246 fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Response, D>::encode(
8248 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
8249 encoder,
8250 offset,
8251 _depth,
8252 )
8253 }
8254 }
8255 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8256 fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D> for (T0,)
8257 {
8258 #[inline]
8259 unsafe fn encode(
8260 self,
8261 encoder: &mut fidl::encoding::Encoder<'_, D>,
8262 offset: usize,
8263 depth: fidl::encoding::Depth,
8264 ) -> fidl::Result<()> {
8265 encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8266 self.0.encode(encoder, offset + 0, depth)?;
8270 Ok(())
8271 }
8272 }
8273
8274 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8275 for AudioCoreGetVolumeFromDb2Response
8276 {
8277 #[inline(always)]
8278 fn new_empty() -> Self {
8279 Self { volume: fidl::new_empty!(f32, D) }
8280 }
8281
8282 #[inline]
8283 unsafe fn decode(
8284 &mut self,
8285 decoder: &mut fidl::encoding::Decoder<'_, D>,
8286 offset: usize,
8287 _depth: fidl::encoding::Depth,
8288 ) -> fidl::Result<()> {
8289 decoder.debug_check_bounds::<Self>(offset);
8290 fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
8292 Ok(())
8293 }
8294 }
8295
8296 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8297 type Borrowed<'a> = &'a Self;
8298 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8299 value
8300 }
8301 }
8302
8303 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8304 type Owned = Self;
8305
8306 #[inline(always)]
8307 fn inline_align(_context: fidl::encoding::Context) -> usize {
8308 8
8309 }
8310
8311 #[inline(always)]
8312 fn inline_size(_context: fidl::encoding::Context) -> usize {
8313 8
8314 }
8315 #[inline(always)]
8316 fn encode_is_copy() -> bool {
8317 true
8318 }
8319
8320 #[inline(always)]
8321 fn decode_is_copy() -> bool {
8322 true
8323 }
8324 }
8325
8326 unsafe impl<D: fidl::encoding::ResourceDialect>
8327 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D>
8328 for &AudioDeviceEnumeratorGetDeviceGainRequest
8329 {
8330 #[inline]
8331 unsafe fn encode(
8332 self,
8333 encoder: &mut fidl::encoding::Encoder<'_, D>,
8334 offset: usize,
8335 _depth: fidl::encoding::Depth,
8336 ) -> fidl::Result<()> {
8337 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8338 unsafe {
8339 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8341 (buf_ptr as *mut AudioDeviceEnumeratorGetDeviceGainRequest).write_unaligned(
8342 (self as *const AudioDeviceEnumeratorGetDeviceGainRequest).read(),
8343 );
8344 }
8347 Ok(())
8348 }
8349 }
8350 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
8351 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D> for (T0,)
8352 {
8353 #[inline]
8354 unsafe fn encode(
8355 self,
8356 encoder: &mut fidl::encoding::Encoder<'_, D>,
8357 offset: usize,
8358 depth: fidl::encoding::Depth,
8359 ) -> fidl::Result<()> {
8360 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8361 self.0.encode(encoder, offset + 0, depth)?;
8365 Ok(())
8366 }
8367 }
8368
8369 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8370 for AudioDeviceEnumeratorGetDeviceGainRequest
8371 {
8372 #[inline(always)]
8373 fn new_empty() -> Self {
8374 Self { device_token: fidl::new_empty!(u64, D) }
8375 }
8376
8377 #[inline]
8378 unsafe fn decode(
8379 &mut self,
8380 decoder: &mut fidl::encoding::Decoder<'_, D>,
8381 offset: usize,
8382 _depth: fidl::encoding::Depth,
8383 ) -> fidl::Result<()> {
8384 decoder.debug_check_bounds::<Self>(offset);
8385 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8386 unsafe {
8389 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
8390 }
8391 Ok(())
8392 }
8393 }
8394
8395 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8396 type Borrowed<'a> = &'a Self;
8397 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8398 value
8399 }
8400 }
8401
8402 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8403 type Owned = Self;
8404
8405 #[inline(always)]
8406 fn inline_align(_context: fidl::encoding::Context) -> usize {
8407 8
8408 }
8409
8410 #[inline(always)]
8411 fn inline_size(_context: fidl::encoding::Context) -> usize {
8412 16
8413 }
8414 }
8415
8416 unsafe impl<D: fidl::encoding::ResourceDialect>
8417 fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D>
8418 for &AudioDeviceEnumeratorGetDeviceGainResponse
8419 {
8420 #[inline]
8421 unsafe fn encode(
8422 self,
8423 encoder: &mut fidl::encoding::Encoder<'_, D>,
8424 offset: usize,
8425 _depth: fidl::encoding::Depth,
8426 ) -> fidl::Result<()> {
8427 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8428 fidl::encoding::Encode::<AudioDeviceEnumeratorGetDeviceGainResponse, D>::encode(
8430 (
8431 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
8432 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
8433 ),
8434 encoder,
8435 offset,
8436 _depth,
8437 )
8438 }
8439 }
8440 unsafe impl<
8441 D: fidl::encoding::ResourceDialect,
8442 T0: fidl::encoding::Encode<u64, D>,
8443 T1: fidl::encoding::Encode<AudioGainInfo, D>,
8444 > fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D> for (T0, T1)
8445 {
8446 #[inline]
8447 unsafe fn encode(
8448 self,
8449 encoder: &mut fidl::encoding::Encoder<'_, D>,
8450 offset: usize,
8451 depth: fidl::encoding::Depth,
8452 ) -> fidl::Result<()> {
8453 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8454 self.0.encode(encoder, offset + 0, depth)?;
8458 self.1.encode(encoder, offset + 8, depth)?;
8459 Ok(())
8460 }
8461 }
8462
8463 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8464 for AudioDeviceEnumeratorGetDeviceGainResponse
8465 {
8466 #[inline(always)]
8467 fn new_empty() -> Self {
8468 Self {
8469 device_token: fidl::new_empty!(u64, D),
8470 gain_info: fidl::new_empty!(AudioGainInfo, D),
8471 }
8472 }
8473
8474 #[inline]
8475 unsafe fn decode(
8476 &mut self,
8477 decoder: &mut fidl::encoding::Decoder<'_, D>,
8478 offset: usize,
8479 _depth: fidl::encoding::Depth,
8480 ) -> fidl::Result<()> {
8481 decoder.debug_check_bounds::<Self>(offset);
8482 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
8484 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
8485 Ok(())
8486 }
8487 }
8488
8489 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDevicesResponse {
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 AudioDeviceEnumeratorGetDevicesResponse {
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 16
8507 }
8508 }
8509
8510 unsafe impl<D: fidl::encoding::ResourceDialect>
8511 fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D>
8512 for &AudioDeviceEnumeratorGetDevicesResponse
8513 {
8514 #[inline]
8515 unsafe fn encode(
8516 self,
8517 encoder: &mut fidl::encoding::Encoder<'_, D>,
8518 offset: usize,
8519 _depth: fidl::encoding::Depth,
8520 ) -> fidl::Result<()> {
8521 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8522 fidl::encoding::Encode::<AudioDeviceEnumeratorGetDevicesResponse, D>::encode(
8524 (
8525 <fidl::encoding::UnboundedVector<AudioDeviceInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.devices),
8526 ),
8527 encoder, offset, _depth
8528 )
8529 }
8530 }
8531 unsafe impl<
8532 D: fidl::encoding::ResourceDialect,
8533 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<AudioDeviceInfo>, D>,
8534 > fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D> for (T0,)
8535 {
8536 #[inline]
8537 unsafe fn encode(
8538 self,
8539 encoder: &mut fidl::encoding::Encoder<'_, D>,
8540 offset: usize,
8541 depth: fidl::encoding::Depth,
8542 ) -> fidl::Result<()> {
8543 encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8544 self.0.encode(encoder, offset + 0, depth)?;
8548 Ok(())
8549 }
8550 }
8551
8552 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8553 for AudioDeviceEnumeratorGetDevicesResponse
8554 {
8555 #[inline(always)]
8556 fn new_empty() -> Self {
8557 Self { devices: fidl::new_empty!(fidl::encoding::UnboundedVector<AudioDeviceInfo>, D) }
8558 }
8559
8560 #[inline]
8561 unsafe fn decode(
8562 &mut self,
8563 decoder: &mut fidl::encoding::Decoder<'_, D>,
8564 offset: usize,
8565 _depth: fidl::encoding::Depth,
8566 ) -> fidl::Result<()> {
8567 decoder.debug_check_bounds::<Self>(offset);
8568 fidl::decode!(
8570 fidl::encoding::UnboundedVector<AudioDeviceInfo>,
8571 D,
8572 &mut self.devices,
8573 decoder,
8574 offset + 0,
8575 _depth
8576 )?;
8577 Ok(())
8578 }
8579 }
8580
8581 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8582 type Borrowed<'a> = &'a Self;
8583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8584 value
8585 }
8586 }
8587
8588 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8589 type Owned = Self;
8590
8591 #[inline(always)]
8592 fn inline_align(_context: fidl::encoding::Context) -> usize {
8593 8
8594 }
8595
8596 #[inline(always)]
8597 fn inline_size(_context: fidl::encoding::Context) -> usize {
8598 16
8599 }
8600 #[inline(always)]
8601 fn encode_is_copy() -> bool {
8602 true
8603 }
8604
8605 #[inline(always)]
8606 fn decode_is_copy() -> bool {
8607 true
8608 }
8609 }
8610
8611 unsafe impl<D: fidl::encoding::ResourceDialect>
8612 fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8613 for &AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8614 {
8615 #[inline]
8616 unsafe fn encode(
8617 self,
8618 encoder: &mut fidl::encoding::Encoder<'_, D>,
8619 offset: usize,
8620 _depth: fidl::encoding::Depth,
8621 ) -> fidl::Result<()> {
8622 encoder
8623 .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8624 unsafe {
8625 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8627 (buf_ptr as *mut AudioDeviceEnumeratorOnDefaultDeviceChangedRequest)
8628 .write_unaligned(
8629 (self as *const AudioDeviceEnumeratorOnDefaultDeviceChangedRequest).read(),
8630 );
8631 }
8634 Ok(())
8635 }
8636 }
8637 unsafe impl<
8638 D: fidl::encoding::ResourceDialect,
8639 T0: fidl::encoding::Encode<u64, D>,
8640 T1: fidl::encoding::Encode<u64, D>,
8641 > fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8642 for (T0, T1)
8643 {
8644 #[inline]
8645 unsafe fn encode(
8646 self,
8647 encoder: &mut fidl::encoding::Encoder<'_, D>,
8648 offset: usize,
8649 depth: fidl::encoding::Depth,
8650 ) -> fidl::Result<()> {
8651 encoder
8652 .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8653 self.0.encode(encoder, offset + 0, depth)?;
8657 self.1.encode(encoder, offset + 8, depth)?;
8658 Ok(())
8659 }
8660 }
8661
8662 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8663 for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8664 {
8665 #[inline(always)]
8666 fn new_empty() -> Self {
8667 Self {
8668 old_default_token: fidl::new_empty!(u64, D),
8669 new_default_token: fidl::new_empty!(u64, D),
8670 }
8671 }
8672
8673 #[inline]
8674 unsafe fn decode(
8675 &mut self,
8676 decoder: &mut fidl::encoding::Decoder<'_, D>,
8677 offset: usize,
8678 _depth: fidl::encoding::Depth,
8679 ) -> fidl::Result<()> {
8680 decoder.debug_check_bounds::<Self>(offset);
8681 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8682 unsafe {
8685 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
8686 }
8687 Ok(())
8688 }
8689 }
8690
8691 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8692 type Borrowed<'a> = &'a Self;
8693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8694 value
8695 }
8696 }
8697
8698 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8699 type Owned = Self;
8700
8701 #[inline(always)]
8702 fn inline_align(_context: fidl::encoding::Context) -> usize {
8703 8
8704 }
8705
8706 #[inline(always)]
8707 fn inline_size(_context: fidl::encoding::Context) -> usize {
8708 56
8709 }
8710 }
8711
8712 unsafe impl<D: fidl::encoding::ResourceDialect>
8713 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D>
8714 for &AudioDeviceEnumeratorOnDeviceAddedRequest
8715 {
8716 #[inline]
8717 unsafe fn encode(
8718 self,
8719 encoder: &mut fidl::encoding::Encoder<'_, D>,
8720 offset: usize,
8721 _depth: fidl::encoding::Depth,
8722 ) -> fidl::Result<()> {
8723 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8724 fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceAddedRequest, D>::encode(
8726 (<AudioDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
8727 encoder,
8728 offset,
8729 _depth,
8730 )
8731 }
8732 }
8733 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioDeviceInfo, D>>
8734 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D> for (T0,)
8735 {
8736 #[inline]
8737 unsafe fn encode(
8738 self,
8739 encoder: &mut fidl::encoding::Encoder<'_, D>,
8740 offset: usize,
8741 depth: fidl::encoding::Depth,
8742 ) -> fidl::Result<()> {
8743 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8744 self.0.encode(encoder, offset + 0, depth)?;
8748 Ok(())
8749 }
8750 }
8751
8752 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8753 for AudioDeviceEnumeratorOnDeviceAddedRequest
8754 {
8755 #[inline(always)]
8756 fn new_empty() -> Self {
8757 Self { device: fidl::new_empty!(AudioDeviceInfo, D) }
8758 }
8759
8760 #[inline]
8761 unsafe fn decode(
8762 &mut self,
8763 decoder: &mut fidl::encoding::Decoder<'_, D>,
8764 offset: usize,
8765 _depth: fidl::encoding::Depth,
8766 ) -> fidl::Result<()> {
8767 decoder.debug_check_bounds::<Self>(offset);
8768 fidl::decode!(AudioDeviceInfo, D, &mut self.device, decoder, offset + 0, _depth)?;
8770 Ok(())
8771 }
8772 }
8773
8774 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceGainChangedRequest {
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 AudioDeviceEnumeratorOnDeviceGainChangedRequest {
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 }
8794
8795 unsafe impl<D: fidl::encoding::ResourceDialect>
8796 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>
8797 for &AudioDeviceEnumeratorOnDeviceGainChangedRequest
8798 {
8799 #[inline]
8800 unsafe fn encode(
8801 self,
8802 encoder: &mut fidl::encoding::Encoder<'_, D>,
8803 offset: usize,
8804 _depth: fidl::encoding::Depth,
8805 ) -> fidl::Result<()> {
8806 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
8807 fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>::encode(
8809 (
8810 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
8811 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
8812 ),
8813 encoder,
8814 offset,
8815 _depth,
8816 )
8817 }
8818 }
8819 unsafe impl<
8820 D: fidl::encoding::ResourceDialect,
8821 T0: fidl::encoding::Encode<u64, D>,
8822 T1: fidl::encoding::Encode<AudioGainInfo, D>,
8823 > fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D> for (T0, T1)
8824 {
8825 #[inline]
8826 unsafe fn encode(
8827 self,
8828 encoder: &mut fidl::encoding::Encoder<'_, D>,
8829 offset: usize,
8830 depth: fidl::encoding::Depth,
8831 ) -> fidl::Result<()> {
8832 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
8833 self.0.encode(encoder, offset + 0, depth)?;
8837 self.1.encode(encoder, offset + 8, depth)?;
8838 Ok(())
8839 }
8840 }
8841
8842 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8843 for AudioDeviceEnumeratorOnDeviceGainChangedRequest
8844 {
8845 #[inline(always)]
8846 fn new_empty() -> Self {
8847 Self {
8848 device_token: fidl::new_empty!(u64, D),
8849 gain_info: fidl::new_empty!(AudioGainInfo, D),
8850 }
8851 }
8852
8853 #[inline]
8854 unsafe fn decode(
8855 &mut self,
8856 decoder: &mut fidl::encoding::Decoder<'_, D>,
8857 offset: usize,
8858 _depth: fidl::encoding::Depth,
8859 ) -> fidl::Result<()> {
8860 decoder.debug_check_bounds::<Self>(offset);
8861 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
8863 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
8864 Ok(())
8865 }
8866 }
8867
8868 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
8869 type Borrowed<'a> = &'a Self;
8870 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8871 value
8872 }
8873 }
8874
8875 unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
8876 type Owned = Self;
8877
8878 #[inline(always)]
8879 fn inline_align(_context: fidl::encoding::Context) -> usize {
8880 8
8881 }
8882
8883 #[inline(always)]
8884 fn inline_size(_context: fidl::encoding::Context) -> usize {
8885 8
8886 }
8887 #[inline(always)]
8888 fn encode_is_copy() -> bool {
8889 true
8890 }
8891
8892 #[inline(always)]
8893 fn decode_is_copy() -> bool {
8894 true
8895 }
8896 }
8897
8898 unsafe impl<D: fidl::encoding::ResourceDialect>
8899 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D>
8900 for &AudioDeviceEnumeratorOnDeviceRemovedRequest
8901 {
8902 #[inline]
8903 unsafe fn encode(
8904 self,
8905 encoder: &mut fidl::encoding::Encoder<'_, D>,
8906 offset: usize,
8907 _depth: fidl::encoding::Depth,
8908 ) -> fidl::Result<()> {
8909 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
8910 unsafe {
8911 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8913 (buf_ptr as *mut AudioDeviceEnumeratorOnDeviceRemovedRequest).write_unaligned(
8914 (self as *const AudioDeviceEnumeratorOnDeviceRemovedRequest).read(),
8915 );
8916 }
8919 Ok(())
8920 }
8921 }
8922 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
8923 fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D> for (T0,)
8924 {
8925 #[inline]
8926 unsafe fn encode(
8927 self,
8928 encoder: &mut fidl::encoding::Encoder<'_, D>,
8929 offset: usize,
8930 depth: fidl::encoding::Depth,
8931 ) -> fidl::Result<()> {
8932 encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
8933 self.0.encode(encoder, offset + 0, depth)?;
8937 Ok(())
8938 }
8939 }
8940
8941 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8942 for AudioDeviceEnumeratorOnDeviceRemovedRequest
8943 {
8944 #[inline(always)]
8945 fn new_empty() -> Self {
8946 Self { device_token: fidl::new_empty!(u64, D) }
8947 }
8948
8949 #[inline]
8950 unsafe fn decode(
8951 &mut self,
8952 decoder: &mut fidl::encoding::Decoder<'_, D>,
8953 offset: usize,
8954 _depth: fidl::encoding::Depth,
8955 ) -> fidl::Result<()> {
8956 decoder.debug_check_bounds::<Self>(offset);
8957 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8958 unsafe {
8961 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
8962 }
8963 Ok(())
8964 }
8965 }
8966
8967 impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorSetDeviceGainRequest {
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 AudioDeviceEnumeratorSetDeviceGainRequest {
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 24
8985 }
8986 }
8987
8988 unsafe impl<D: fidl::encoding::ResourceDialect>
8989 fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D>
8990 for &AudioDeviceEnumeratorSetDeviceGainRequest
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::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9000 fidl::encoding::Encode::<AudioDeviceEnumeratorSetDeviceGainRequest, D>::encode(
9002 (
9003 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
9004 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9005 <AudioGainValidFlags as fidl::encoding::ValueTypeMarker>::borrow(
9006 &self.valid_flags,
9007 ),
9008 ),
9009 encoder,
9010 offset,
9011 _depth,
9012 )
9013 }
9014 }
9015 unsafe impl<
9016 D: fidl::encoding::ResourceDialect,
9017 T0: fidl::encoding::Encode<u64, D>,
9018 T1: fidl::encoding::Encode<AudioGainInfo, D>,
9019 T2: fidl::encoding::Encode<AudioGainValidFlags, D>,
9020 > fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D> for (T0, T1, T2)
9021 {
9022 #[inline]
9023 unsafe fn encode(
9024 self,
9025 encoder: &mut fidl::encoding::Encoder<'_, D>,
9026 offset: usize,
9027 depth: fidl::encoding::Depth,
9028 ) -> fidl::Result<()> {
9029 encoder.debug_check_bounds::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9030 unsafe {
9033 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
9034 (ptr as *mut u64).write_unaligned(0);
9035 }
9036 self.0.encode(encoder, offset + 0, depth)?;
9038 self.1.encode(encoder, offset + 8, depth)?;
9039 self.2.encode(encoder, offset + 16, depth)?;
9040 Ok(())
9041 }
9042 }
9043
9044 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9045 for AudioDeviceEnumeratorSetDeviceGainRequest
9046 {
9047 #[inline(always)]
9048 fn new_empty() -> Self {
9049 Self {
9050 device_token: fidl::new_empty!(u64, D),
9051 gain_info: fidl::new_empty!(AudioGainInfo, D),
9052 valid_flags: fidl::new_empty!(AudioGainValidFlags, D),
9053 }
9054 }
9055
9056 #[inline]
9057 unsafe fn decode(
9058 &mut self,
9059 decoder: &mut fidl::encoding::Decoder<'_, D>,
9060 offset: usize,
9061 _depth: fidl::encoding::Depth,
9062 ) -> fidl::Result<()> {
9063 decoder.debug_check_bounds::<Self>(offset);
9064 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
9066 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9067 let mask = 0xffffffff00000000u64;
9068 let maskedval = padval & mask;
9069 if maskedval != 0 {
9070 return Err(fidl::Error::NonZeroPadding {
9071 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
9072 });
9073 }
9074 fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
9075 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
9076 fidl::decode!(
9077 AudioGainValidFlags,
9078 D,
9079 &mut self.valid_flags,
9080 decoder,
9081 offset + 16,
9082 _depth
9083 )?;
9084 Ok(())
9085 }
9086 }
9087
9088 impl fidl::encoding::ValueTypeMarker for AudioDeviceInfo {
9089 type Borrowed<'a> = &'a Self;
9090 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9091 value
9092 }
9093 }
9094
9095 unsafe impl fidl::encoding::TypeMarker for AudioDeviceInfo {
9096 type Owned = Self;
9097
9098 #[inline(always)]
9099 fn inline_align(_context: fidl::encoding::Context) -> usize {
9100 8
9101 }
9102
9103 #[inline(always)]
9104 fn inline_size(_context: fidl::encoding::Context) -> usize {
9105 56
9106 }
9107 }
9108
9109 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioDeviceInfo, D>
9110 for &AudioDeviceInfo
9111 {
9112 #[inline]
9113 unsafe fn encode(
9114 self,
9115 encoder: &mut fidl::encoding::Encoder<'_, D>,
9116 offset: usize,
9117 _depth: fidl::encoding::Depth,
9118 ) -> fidl::Result<()> {
9119 encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9120 fidl::encoding::Encode::<AudioDeviceInfo, D>::encode(
9122 (
9123 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9124 &self.name,
9125 ),
9126 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9127 &self.unique_id,
9128 ),
9129 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.token_id),
9130 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_input),
9131 <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9132 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_default),
9133 ),
9134 encoder,
9135 offset,
9136 _depth,
9137 )
9138 }
9139 }
9140 unsafe impl<
9141 D: fidl::encoding::ResourceDialect,
9142 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9143 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9144 T2: fidl::encoding::Encode<u64, D>,
9145 T3: fidl::encoding::Encode<bool, D>,
9146 T4: fidl::encoding::Encode<AudioGainInfo, D>,
9147 T5: fidl::encoding::Encode<bool, D>,
9148 > fidl::encoding::Encode<AudioDeviceInfo, D> for (T0, T1, T2, T3, T4, T5)
9149 {
9150 #[inline]
9151 unsafe fn encode(
9152 self,
9153 encoder: &mut fidl::encoding::Encoder<'_, D>,
9154 offset: usize,
9155 depth: fidl::encoding::Depth,
9156 ) -> fidl::Result<()> {
9157 encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9158 unsafe {
9161 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
9162 (ptr as *mut u64).write_unaligned(0);
9163 }
9164 unsafe {
9165 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
9166 (ptr as *mut u64).write_unaligned(0);
9167 }
9168 self.0.encode(encoder, offset + 0, depth)?;
9170 self.1.encode(encoder, offset + 16, depth)?;
9171 self.2.encode(encoder, offset + 32, depth)?;
9172 self.3.encode(encoder, offset + 40, depth)?;
9173 self.4.encode(encoder, offset + 44, depth)?;
9174 self.5.encode(encoder, offset + 52, depth)?;
9175 Ok(())
9176 }
9177 }
9178
9179 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioDeviceInfo {
9180 #[inline(always)]
9181 fn new_empty() -> Self {
9182 Self {
9183 name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9184 unique_id: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9185 token_id: fidl::new_empty!(u64, D),
9186 is_input: fidl::new_empty!(bool, D),
9187 gain_info: fidl::new_empty!(AudioGainInfo, D),
9188 is_default: fidl::new_empty!(bool, D),
9189 }
9190 }
9191
9192 #[inline]
9193 unsafe fn decode(
9194 &mut self,
9195 decoder: &mut fidl::encoding::Decoder<'_, D>,
9196 offset: usize,
9197 _depth: fidl::encoding::Depth,
9198 ) -> fidl::Result<()> {
9199 decoder.debug_check_bounds::<Self>(offset);
9200 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
9202 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9203 let mask = 0xffffff00u64;
9204 let maskedval = padval & mask;
9205 if maskedval != 0 {
9206 return Err(fidl::Error::NonZeroPadding {
9207 padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
9208 });
9209 }
9210 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
9211 let padval = unsafe { (ptr as *const u64).read_unaligned() };
9212 let mask = 0xffffff0000000000u64;
9213 let maskedval = padval & mask;
9214 if maskedval != 0 {
9215 return Err(fidl::Error::NonZeroPadding {
9216 padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
9217 });
9218 }
9219 fidl::decode!(
9220 fidl::encoding::UnboundedString,
9221 D,
9222 &mut self.name,
9223 decoder,
9224 offset + 0,
9225 _depth
9226 )?;
9227 fidl::decode!(
9228 fidl::encoding::UnboundedString,
9229 D,
9230 &mut self.unique_id,
9231 decoder,
9232 offset + 16,
9233 _depth
9234 )?;
9235 fidl::decode!(u64, D, &mut self.token_id, decoder, offset + 32, _depth)?;
9236 fidl::decode!(bool, D, &mut self.is_input, decoder, offset + 40, _depth)?;
9237 fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 44, _depth)?;
9238 fidl::decode!(bool, D, &mut self.is_default, decoder, offset + 52, _depth)?;
9239 Ok(())
9240 }
9241 }
9242
9243 impl fidl::encoding::ValueTypeMarker for AudioGainInfo {
9244 type Borrowed<'a> = &'a Self;
9245 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9246 value
9247 }
9248 }
9249
9250 unsafe impl fidl::encoding::TypeMarker for AudioGainInfo {
9251 type Owned = Self;
9252
9253 #[inline(always)]
9254 fn inline_align(_context: fidl::encoding::Context) -> usize {
9255 4
9256 }
9257
9258 #[inline(always)]
9259 fn inline_size(_context: fidl::encoding::Context) -> usize {
9260 8
9261 }
9262 }
9263
9264 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioGainInfo, D>
9265 for &AudioGainInfo
9266 {
9267 #[inline]
9268 unsafe fn encode(
9269 self,
9270 encoder: &mut fidl::encoding::Encoder<'_, D>,
9271 offset: usize,
9272 _depth: fidl::encoding::Depth,
9273 ) -> fidl::Result<()> {
9274 encoder.debug_check_bounds::<AudioGainInfo>(offset);
9275 fidl::encoding::Encode::<AudioGainInfo, D>::encode(
9277 (
9278 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
9279 <AudioGainInfoFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
9280 ),
9281 encoder,
9282 offset,
9283 _depth,
9284 )
9285 }
9286 }
9287 unsafe impl<
9288 D: fidl::encoding::ResourceDialect,
9289 T0: fidl::encoding::Encode<f32, D>,
9290 T1: fidl::encoding::Encode<AudioGainInfoFlags, D>,
9291 > fidl::encoding::Encode<AudioGainInfo, D> for (T0, T1)
9292 {
9293 #[inline]
9294 unsafe fn encode(
9295 self,
9296 encoder: &mut fidl::encoding::Encoder<'_, D>,
9297 offset: usize,
9298 depth: fidl::encoding::Depth,
9299 ) -> fidl::Result<()> {
9300 encoder.debug_check_bounds::<AudioGainInfo>(offset);
9301 self.0.encode(encoder, offset + 0, depth)?;
9305 self.1.encode(encoder, offset + 4, depth)?;
9306 Ok(())
9307 }
9308 }
9309
9310 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfo {
9311 #[inline(always)]
9312 fn new_empty() -> Self {
9313 Self {
9314 gain_db: fidl::new_empty!(f32, D),
9315 flags: fidl::new_empty!(AudioGainInfoFlags, D),
9316 }
9317 }
9318
9319 #[inline]
9320 unsafe fn decode(
9321 &mut self,
9322 decoder: &mut fidl::encoding::Decoder<'_, D>,
9323 offset: usize,
9324 _depth: fidl::encoding::Depth,
9325 ) -> fidl::Result<()> {
9326 decoder.debug_check_bounds::<Self>(offset);
9327 fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
9329 fidl::decode!(AudioGainInfoFlags, D, &mut self.flags, decoder, offset + 4, _depth)?;
9330 Ok(())
9331 }
9332 }
9333
9334 impl fidl::encoding::ValueTypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9335 type Borrowed<'a> = &'a Self;
9336 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9337 value
9338 }
9339 }
9340
9341 unsafe impl fidl::encoding::TypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9342 type Owned = Self;
9343
9344 #[inline(always)]
9345 fn inline_align(_context: fidl::encoding::Context) -> usize {
9346 1
9347 }
9348
9349 #[inline(always)]
9350 fn inline_size(_context: fidl::encoding::Context) -> usize {
9351 1
9352 }
9353 }
9354
9355 unsafe impl<D: fidl::encoding::ResourceDialect>
9356 fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D>
9357 for &AudioRendererEnableMinLeadTimeEventsRequest
9358 {
9359 #[inline]
9360 unsafe fn encode(
9361 self,
9362 encoder: &mut fidl::encoding::Encoder<'_, D>,
9363 offset: usize,
9364 _depth: fidl::encoding::Depth,
9365 ) -> fidl::Result<()> {
9366 encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9367 fidl::encoding::Encode::<AudioRendererEnableMinLeadTimeEventsRequest, D>::encode(
9369 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
9370 encoder,
9371 offset,
9372 _depth,
9373 )
9374 }
9375 }
9376 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
9377 fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D> for (T0,)
9378 {
9379 #[inline]
9380 unsafe fn encode(
9381 self,
9382 encoder: &mut fidl::encoding::Encoder<'_, D>,
9383 offset: usize,
9384 depth: fidl::encoding::Depth,
9385 ) -> fidl::Result<()> {
9386 encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9387 self.0.encode(encoder, offset + 0, depth)?;
9391 Ok(())
9392 }
9393 }
9394
9395 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9396 for AudioRendererEnableMinLeadTimeEventsRequest
9397 {
9398 #[inline(always)]
9399 fn new_empty() -> Self {
9400 Self { enabled: fidl::new_empty!(bool, D) }
9401 }
9402
9403 #[inline]
9404 unsafe fn decode(
9405 &mut self,
9406 decoder: &mut fidl::encoding::Decoder<'_, D>,
9407 offset: usize,
9408 _depth: fidl::encoding::Depth,
9409 ) -> fidl::Result<()> {
9410 decoder.debug_check_bounds::<Self>(offset);
9411 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
9413 Ok(())
9414 }
9415 }
9416
9417 impl fidl::encoding::ValueTypeMarker for AudioRendererGetMinLeadTimeResponse {
9418 type Borrowed<'a> = &'a Self;
9419 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9420 value
9421 }
9422 }
9423
9424 unsafe impl fidl::encoding::TypeMarker for AudioRendererGetMinLeadTimeResponse {
9425 type Owned = Self;
9426
9427 #[inline(always)]
9428 fn inline_align(_context: fidl::encoding::Context) -> usize {
9429 8
9430 }
9431
9432 #[inline(always)]
9433 fn inline_size(_context: fidl::encoding::Context) -> usize {
9434 8
9435 }
9436 #[inline(always)]
9437 fn encode_is_copy() -> bool {
9438 true
9439 }
9440
9441 #[inline(always)]
9442 fn decode_is_copy() -> bool {
9443 true
9444 }
9445 }
9446
9447 unsafe impl<D: fidl::encoding::ResourceDialect>
9448 fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D>
9449 for &AudioRendererGetMinLeadTimeResponse
9450 {
9451 #[inline]
9452 unsafe fn encode(
9453 self,
9454 encoder: &mut fidl::encoding::Encoder<'_, D>,
9455 offset: usize,
9456 _depth: fidl::encoding::Depth,
9457 ) -> fidl::Result<()> {
9458 encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9459 unsafe {
9460 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9462 (buf_ptr as *mut AudioRendererGetMinLeadTimeResponse)
9463 .write_unaligned((self as *const AudioRendererGetMinLeadTimeResponse).read());
9464 }
9467 Ok(())
9468 }
9469 }
9470 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9471 fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D> for (T0,)
9472 {
9473 #[inline]
9474 unsafe fn encode(
9475 self,
9476 encoder: &mut fidl::encoding::Encoder<'_, D>,
9477 offset: usize,
9478 depth: fidl::encoding::Depth,
9479 ) -> fidl::Result<()> {
9480 encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9481 self.0.encode(encoder, offset + 0, depth)?;
9485 Ok(())
9486 }
9487 }
9488
9489 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9490 for AudioRendererGetMinLeadTimeResponse
9491 {
9492 #[inline(always)]
9493 fn new_empty() -> Self {
9494 Self { min_lead_time_nsec: fidl::new_empty!(i64, D) }
9495 }
9496
9497 #[inline]
9498 unsafe fn decode(
9499 &mut self,
9500 decoder: &mut fidl::encoding::Decoder<'_, D>,
9501 offset: usize,
9502 _depth: fidl::encoding::Depth,
9503 ) -> fidl::Result<()> {
9504 decoder.debug_check_bounds::<Self>(offset);
9505 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9506 unsafe {
9509 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9510 }
9511 Ok(())
9512 }
9513 }
9514
9515 impl fidl::encoding::ValueTypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9516 type Borrowed<'a> = &'a Self;
9517 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9518 value
9519 }
9520 }
9521
9522 unsafe impl fidl::encoding::TypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9523 type Owned = Self;
9524
9525 #[inline(always)]
9526 fn inline_align(_context: fidl::encoding::Context) -> usize {
9527 8
9528 }
9529
9530 #[inline(always)]
9531 fn inline_size(_context: fidl::encoding::Context) -> usize {
9532 8
9533 }
9534 #[inline(always)]
9535 fn encode_is_copy() -> bool {
9536 true
9537 }
9538
9539 #[inline(always)]
9540 fn decode_is_copy() -> bool {
9541 true
9542 }
9543 }
9544
9545 unsafe impl<D: fidl::encoding::ResourceDialect>
9546 fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, D>
9547 for &AudioRendererOnMinLeadTimeChangedRequest
9548 {
9549 #[inline]
9550 unsafe fn encode(
9551 self,
9552 encoder: &mut fidl::encoding::Encoder<'_, D>,
9553 offset: usize,
9554 _depth: fidl::encoding::Depth,
9555 ) -> fidl::Result<()> {
9556 encoder.debug_check_bounds::<AudioRendererOnMinLeadTimeChangedRequest>(offset);
9557 unsafe {
9558 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9560 (buf_ptr as *mut AudioRendererOnMinLeadTimeChangedRequest).write_unaligned(
9561 (self as *const AudioRendererOnMinLeadTimeChangedRequest).read(),
9562 );
9563 }
9566 Ok(())
9567 }
9568 }
9569 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9570 fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, 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::<AudioRendererOnMinLeadTimeChangedRequest>(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 AudioRendererOnMinLeadTimeChangedRequest
9590 {
9591 #[inline(always)]
9592 fn new_empty() -> Self {
9593 Self { min_lead_time_nsec: fidl::new_empty!(i64, 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 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9605 unsafe {
9608 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9609 }
9610 Ok(())
9611 }
9612 }
9613
9614 impl fidl::encoding::ValueTypeMarker for AudioRendererPauseResponse {
9615 type Borrowed<'a> = &'a Self;
9616 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9617 value
9618 }
9619 }
9620
9621 unsafe impl fidl::encoding::TypeMarker for AudioRendererPauseResponse {
9622 type Owned = Self;
9623
9624 #[inline(always)]
9625 fn inline_align(_context: fidl::encoding::Context) -> usize {
9626 8
9627 }
9628
9629 #[inline(always)]
9630 fn inline_size(_context: fidl::encoding::Context) -> usize {
9631 16
9632 }
9633 #[inline(always)]
9634 fn encode_is_copy() -> bool {
9635 true
9636 }
9637
9638 #[inline(always)]
9639 fn decode_is_copy() -> bool {
9640 true
9641 }
9642 }
9643
9644 unsafe impl<D: fidl::encoding::ResourceDialect>
9645 fidl::encoding::Encode<AudioRendererPauseResponse, D> for &AudioRendererPauseResponse
9646 {
9647 #[inline]
9648 unsafe fn encode(
9649 self,
9650 encoder: &mut fidl::encoding::Encoder<'_, D>,
9651 offset: usize,
9652 _depth: fidl::encoding::Depth,
9653 ) -> fidl::Result<()> {
9654 encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9655 unsafe {
9656 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9658 (buf_ptr as *mut AudioRendererPauseResponse)
9659 .write_unaligned((self as *const AudioRendererPauseResponse).read());
9660 }
9663 Ok(())
9664 }
9665 }
9666 unsafe impl<
9667 D: fidl::encoding::ResourceDialect,
9668 T0: fidl::encoding::Encode<i64, D>,
9669 T1: fidl::encoding::Encode<i64, D>,
9670 > fidl::encoding::Encode<AudioRendererPauseResponse, D> for (T0, T1)
9671 {
9672 #[inline]
9673 unsafe fn encode(
9674 self,
9675 encoder: &mut fidl::encoding::Encoder<'_, D>,
9676 offset: usize,
9677 depth: fidl::encoding::Depth,
9678 ) -> fidl::Result<()> {
9679 encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9680 self.0.encode(encoder, offset + 0, depth)?;
9684 self.1.encode(encoder, offset + 8, depth)?;
9685 Ok(())
9686 }
9687 }
9688
9689 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9690 for AudioRendererPauseResponse
9691 {
9692 #[inline(always)]
9693 fn new_empty() -> Self {
9694 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9695 }
9696
9697 #[inline]
9698 unsafe fn decode(
9699 &mut self,
9700 decoder: &mut fidl::encoding::Decoder<'_, D>,
9701 offset: usize,
9702 _depth: fidl::encoding::Depth,
9703 ) -> fidl::Result<()> {
9704 decoder.debug_check_bounds::<Self>(offset);
9705 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9706 unsafe {
9709 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
9710 }
9711 Ok(())
9712 }
9713 }
9714
9715 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayNoReplyRequest {
9716 type Borrowed<'a> = &'a Self;
9717 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9718 value
9719 }
9720 }
9721
9722 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayNoReplyRequest {
9723 type Owned = Self;
9724
9725 #[inline(always)]
9726 fn inline_align(_context: fidl::encoding::Context) -> usize {
9727 8
9728 }
9729
9730 #[inline(always)]
9731 fn inline_size(_context: fidl::encoding::Context) -> usize {
9732 16
9733 }
9734 #[inline(always)]
9735 fn encode_is_copy() -> bool {
9736 true
9737 }
9738
9739 #[inline(always)]
9740 fn decode_is_copy() -> bool {
9741 true
9742 }
9743 }
9744
9745 unsafe impl<D: fidl::encoding::ResourceDialect>
9746 fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D>
9747 for &AudioRendererPlayNoReplyRequest
9748 {
9749 #[inline]
9750 unsafe fn encode(
9751 self,
9752 encoder: &mut fidl::encoding::Encoder<'_, D>,
9753 offset: usize,
9754 _depth: fidl::encoding::Depth,
9755 ) -> fidl::Result<()> {
9756 encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9757 unsafe {
9758 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9760 (buf_ptr as *mut AudioRendererPlayNoReplyRequest)
9761 .write_unaligned((self as *const AudioRendererPlayNoReplyRequest).read());
9762 }
9765 Ok(())
9766 }
9767 }
9768 unsafe impl<
9769 D: fidl::encoding::ResourceDialect,
9770 T0: fidl::encoding::Encode<i64, D>,
9771 T1: fidl::encoding::Encode<i64, D>,
9772 > fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D> for (T0, T1)
9773 {
9774 #[inline]
9775 unsafe fn encode(
9776 self,
9777 encoder: &mut fidl::encoding::Encoder<'_, D>,
9778 offset: usize,
9779 depth: fidl::encoding::Depth,
9780 ) -> fidl::Result<()> {
9781 encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9782 self.0.encode(encoder, offset + 0, depth)?;
9786 self.1.encode(encoder, offset + 8, depth)?;
9787 Ok(())
9788 }
9789 }
9790
9791 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9792 for AudioRendererPlayNoReplyRequest
9793 {
9794 #[inline(always)]
9795 fn new_empty() -> Self {
9796 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9797 }
9798
9799 #[inline]
9800 unsafe fn decode(
9801 &mut self,
9802 decoder: &mut fidl::encoding::Decoder<'_, D>,
9803 offset: usize,
9804 _depth: fidl::encoding::Depth,
9805 ) -> fidl::Result<()> {
9806 decoder.debug_check_bounds::<Self>(offset);
9807 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9808 unsafe {
9811 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
9812 }
9813 Ok(())
9814 }
9815 }
9816
9817 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayRequest {
9818 type Borrowed<'a> = &'a Self;
9819 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9820 value
9821 }
9822 }
9823
9824 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayRequest {
9825 type Owned = Self;
9826
9827 #[inline(always)]
9828 fn inline_align(_context: fidl::encoding::Context) -> usize {
9829 8
9830 }
9831
9832 #[inline(always)]
9833 fn inline_size(_context: fidl::encoding::Context) -> usize {
9834 16
9835 }
9836 #[inline(always)]
9837 fn encode_is_copy() -> bool {
9838 true
9839 }
9840
9841 #[inline(always)]
9842 fn decode_is_copy() -> bool {
9843 true
9844 }
9845 }
9846
9847 unsafe impl<D: fidl::encoding::ResourceDialect>
9848 fidl::encoding::Encode<AudioRendererPlayRequest, D> for &AudioRendererPlayRequest
9849 {
9850 #[inline]
9851 unsafe fn encode(
9852 self,
9853 encoder: &mut fidl::encoding::Encoder<'_, D>,
9854 offset: usize,
9855 _depth: fidl::encoding::Depth,
9856 ) -> fidl::Result<()> {
9857 encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
9858 unsafe {
9859 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9861 (buf_ptr as *mut AudioRendererPlayRequest)
9862 .write_unaligned((self as *const AudioRendererPlayRequest).read());
9863 }
9866 Ok(())
9867 }
9868 }
9869 unsafe impl<
9870 D: fidl::encoding::ResourceDialect,
9871 T0: fidl::encoding::Encode<i64, D>,
9872 T1: fidl::encoding::Encode<i64, D>,
9873 > fidl::encoding::Encode<AudioRendererPlayRequest, D> for (T0, T1)
9874 {
9875 #[inline]
9876 unsafe fn encode(
9877 self,
9878 encoder: &mut fidl::encoding::Encoder<'_, D>,
9879 offset: usize,
9880 depth: fidl::encoding::Depth,
9881 ) -> fidl::Result<()> {
9882 encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
9883 self.0.encode(encoder, offset + 0, depth)?;
9887 self.1.encode(encoder, offset + 8, depth)?;
9888 Ok(())
9889 }
9890 }
9891
9892 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9893 for AudioRendererPlayRequest
9894 {
9895 #[inline(always)]
9896 fn new_empty() -> Self {
9897 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9898 }
9899
9900 #[inline]
9901 unsafe fn decode(
9902 &mut self,
9903 decoder: &mut fidl::encoding::Decoder<'_, D>,
9904 offset: usize,
9905 _depth: fidl::encoding::Depth,
9906 ) -> fidl::Result<()> {
9907 decoder.debug_check_bounds::<Self>(offset);
9908 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9909 unsafe {
9912 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
9913 }
9914 Ok(())
9915 }
9916 }
9917
9918 impl fidl::encoding::ValueTypeMarker for AudioRendererPlayResponse {
9919 type Borrowed<'a> = &'a Self;
9920 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9921 value
9922 }
9923 }
9924
9925 unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayResponse {
9926 type Owned = Self;
9927
9928 #[inline(always)]
9929 fn inline_align(_context: fidl::encoding::Context) -> usize {
9930 8
9931 }
9932
9933 #[inline(always)]
9934 fn inline_size(_context: fidl::encoding::Context) -> usize {
9935 16
9936 }
9937 #[inline(always)]
9938 fn encode_is_copy() -> bool {
9939 true
9940 }
9941
9942 #[inline(always)]
9943 fn decode_is_copy() -> bool {
9944 true
9945 }
9946 }
9947
9948 unsafe impl<D: fidl::encoding::ResourceDialect>
9949 fidl::encoding::Encode<AudioRendererPlayResponse, D> for &AudioRendererPlayResponse
9950 {
9951 #[inline]
9952 unsafe fn encode(
9953 self,
9954 encoder: &mut fidl::encoding::Encoder<'_, D>,
9955 offset: usize,
9956 _depth: fidl::encoding::Depth,
9957 ) -> fidl::Result<()> {
9958 encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
9959 unsafe {
9960 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9962 (buf_ptr as *mut AudioRendererPlayResponse)
9963 .write_unaligned((self as *const AudioRendererPlayResponse).read());
9964 }
9967 Ok(())
9968 }
9969 }
9970 unsafe impl<
9971 D: fidl::encoding::ResourceDialect,
9972 T0: fidl::encoding::Encode<i64, D>,
9973 T1: fidl::encoding::Encode<i64, D>,
9974 > fidl::encoding::Encode<AudioRendererPlayResponse, D> for (T0, T1)
9975 {
9976 #[inline]
9977 unsafe fn encode(
9978 self,
9979 encoder: &mut fidl::encoding::Encoder<'_, D>,
9980 offset: usize,
9981 depth: fidl::encoding::Depth,
9982 ) -> fidl::Result<()> {
9983 encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
9984 self.0.encode(encoder, offset + 0, depth)?;
9988 self.1.encode(encoder, offset + 8, depth)?;
9989 Ok(())
9990 }
9991 }
9992
9993 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9994 for AudioRendererPlayResponse
9995 {
9996 #[inline(always)]
9997 fn new_empty() -> Self {
9998 Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9999 }
10000
10001 #[inline]
10002 unsafe fn decode(
10003 &mut self,
10004 decoder: &mut fidl::encoding::Decoder<'_, D>,
10005 offset: usize,
10006 _depth: fidl::encoding::Depth,
10007 ) -> fidl::Result<()> {
10008 decoder.debug_check_bounds::<Self>(offset);
10009 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10010 unsafe {
10013 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10014 }
10015 Ok(())
10016 }
10017 }
10018
10019 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPcmStreamTypeRequest {
10020 type Borrowed<'a> = &'a Self;
10021 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10022 value
10023 }
10024 }
10025
10026 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPcmStreamTypeRequest {
10027 type Owned = Self;
10028
10029 #[inline(always)]
10030 fn inline_align(_context: fidl::encoding::Context) -> usize {
10031 4
10032 }
10033
10034 #[inline(always)]
10035 fn inline_size(_context: fidl::encoding::Context) -> usize {
10036 12
10037 }
10038 }
10039
10040 unsafe impl<D: fidl::encoding::ResourceDialect>
10041 fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D>
10042 for &AudioRendererSetPcmStreamTypeRequest
10043 {
10044 #[inline]
10045 unsafe fn encode(
10046 self,
10047 encoder: &mut fidl::encoding::Encoder<'_, D>,
10048 offset: usize,
10049 _depth: fidl::encoding::Depth,
10050 ) -> fidl::Result<()> {
10051 encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10052 fidl::encoding::Encode::<AudioRendererSetPcmStreamTypeRequest, D>::encode(
10054 (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
10055 encoder,
10056 offset,
10057 _depth,
10058 )
10059 }
10060 }
10061 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
10062 fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D> for (T0,)
10063 {
10064 #[inline]
10065 unsafe fn encode(
10066 self,
10067 encoder: &mut fidl::encoding::Encoder<'_, D>,
10068 offset: usize,
10069 depth: fidl::encoding::Depth,
10070 ) -> fidl::Result<()> {
10071 encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10072 self.0.encode(encoder, offset + 0, depth)?;
10076 Ok(())
10077 }
10078 }
10079
10080 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10081 for AudioRendererSetPcmStreamTypeRequest
10082 {
10083 #[inline(always)]
10084 fn new_empty() -> Self {
10085 Self { type_: fidl::new_empty!(AudioStreamType, D) }
10086 }
10087
10088 #[inline]
10089 unsafe fn decode(
10090 &mut self,
10091 decoder: &mut fidl::encoding::Decoder<'_, D>,
10092 offset: usize,
10093 _depth: fidl::encoding::Depth,
10094 ) -> fidl::Result<()> {
10095 decoder.debug_check_bounds::<Self>(offset);
10096 fidl::decode!(AudioStreamType, D, &mut self.type_, decoder, offset + 0, _depth)?;
10098 Ok(())
10099 }
10100 }
10101
10102 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10103 type Borrowed<'a> = &'a Self;
10104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10105 value
10106 }
10107 }
10108
10109 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10110 type Owned = Self;
10111
10112 #[inline(always)]
10113 fn inline_align(_context: fidl::encoding::Context) -> usize {
10114 4
10115 }
10116
10117 #[inline(always)]
10118 fn inline_size(_context: fidl::encoding::Context) -> usize {
10119 4
10120 }
10121 }
10122
10123 unsafe impl<D: fidl::encoding::ResourceDialect>
10124 fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D>
10125 for &AudioRendererSetPtsContinuityThresholdRequest
10126 {
10127 #[inline]
10128 unsafe fn encode(
10129 self,
10130 encoder: &mut fidl::encoding::Encoder<'_, D>,
10131 offset: usize,
10132 _depth: fidl::encoding::Depth,
10133 ) -> fidl::Result<()> {
10134 encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10135 fidl::encoding::Encode::<AudioRendererSetPtsContinuityThresholdRequest, D>::encode(
10137 (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.threshold_seconds),),
10138 encoder,
10139 offset,
10140 _depth,
10141 )
10142 }
10143 }
10144 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
10145 fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D> for (T0,)
10146 {
10147 #[inline]
10148 unsafe fn encode(
10149 self,
10150 encoder: &mut fidl::encoding::Encoder<'_, D>,
10151 offset: usize,
10152 depth: fidl::encoding::Depth,
10153 ) -> fidl::Result<()> {
10154 encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10155 self.0.encode(encoder, offset + 0, depth)?;
10159 Ok(())
10160 }
10161 }
10162
10163 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10164 for AudioRendererSetPtsContinuityThresholdRequest
10165 {
10166 #[inline(always)]
10167 fn new_empty() -> Self {
10168 Self { threshold_seconds: fidl::new_empty!(f32, D) }
10169 }
10170
10171 #[inline]
10172 unsafe fn decode(
10173 &mut self,
10174 decoder: &mut fidl::encoding::Decoder<'_, D>,
10175 offset: usize,
10176 _depth: fidl::encoding::Depth,
10177 ) -> fidl::Result<()> {
10178 decoder.debug_check_bounds::<Self>(offset);
10179 fidl::decode!(f32, D, &mut self.threshold_seconds, decoder, offset + 0, _depth)?;
10181 Ok(())
10182 }
10183 }
10184
10185 impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsUnitsRequest {
10186 type Borrowed<'a> = &'a Self;
10187 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10188 value
10189 }
10190 }
10191
10192 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsUnitsRequest {
10193 type Owned = Self;
10194
10195 #[inline(always)]
10196 fn inline_align(_context: fidl::encoding::Context) -> usize {
10197 4
10198 }
10199
10200 #[inline(always)]
10201 fn inline_size(_context: fidl::encoding::Context) -> usize {
10202 8
10203 }
10204 #[inline(always)]
10205 fn encode_is_copy() -> bool {
10206 true
10207 }
10208
10209 #[inline(always)]
10210 fn decode_is_copy() -> bool {
10211 true
10212 }
10213 }
10214
10215 unsafe impl<D: fidl::encoding::ResourceDialect>
10216 fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D>
10217 for &AudioRendererSetPtsUnitsRequest
10218 {
10219 #[inline]
10220 unsafe fn encode(
10221 self,
10222 encoder: &mut fidl::encoding::Encoder<'_, D>,
10223 offset: usize,
10224 _depth: fidl::encoding::Depth,
10225 ) -> fidl::Result<()> {
10226 encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10227 unsafe {
10228 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10230 (buf_ptr as *mut AudioRendererSetPtsUnitsRequest)
10231 .write_unaligned((self as *const AudioRendererSetPtsUnitsRequest).read());
10232 }
10235 Ok(())
10236 }
10237 }
10238 unsafe impl<
10239 D: fidl::encoding::ResourceDialect,
10240 T0: fidl::encoding::Encode<u32, D>,
10241 T1: fidl::encoding::Encode<u32, D>,
10242 > fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D> for (T0, T1)
10243 {
10244 #[inline]
10245 unsafe fn encode(
10246 self,
10247 encoder: &mut fidl::encoding::Encoder<'_, D>,
10248 offset: usize,
10249 depth: fidl::encoding::Depth,
10250 ) -> fidl::Result<()> {
10251 encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10252 self.0.encode(encoder, offset + 0, depth)?;
10256 self.1.encode(encoder, offset + 4, depth)?;
10257 Ok(())
10258 }
10259 }
10260
10261 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10262 for AudioRendererSetPtsUnitsRequest
10263 {
10264 #[inline(always)]
10265 fn new_empty() -> Self {
10266 Self {
10267 tick_per_second_numerator: fidl::new_empty!(u32, D),
10268 tick_per_second_denominator: fidl::new_empty!(u32, D),
10269 }
10270 }
10271
10272 #[inline]
10273 unsafe fn decode(
10274 &mut self,
10275 decoder: &mut fidl::encoding::Decoder<'_, D>,
10276 offset: usize,
10277 _depth: fidl::encoding::Depth,
10278 ) -> fidl::Result<()> {
10279 decoder.debug_check_bounds::<Self>(offset);
10280 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10281 unsafe {
10284 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10285 }
10286 Ok(())
10287 }
10288 }
10289
10290 impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsage2Request {
10291 type Borrowed<'a> = &'a Self;
10292 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10293 value
10294 }
10295 }
10296
10297 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsage2Request {
10298 type Owned = Self;
10299
10300 #[inline(always)]
10301 fn inline_align(_context: fidl::encoding::Context) -> usize {
10302 4
10303 }
10304
10305 #[inline(always)]
10306 fn inline_size(_context: fidl::encoding::Context) -> usize {
10307 4
10308 }
10309 }
10310
10311 unsafe impl<D: fidl::encoding::ResourceDialect>
10312 fidl::encoding::Encode<AudioRendererSetUsage2Request, D>
10313 for &AudioRendererSetUsage2Request
10314 {
10315 #[inline]
10316 unsafe fn encode(
10317 self,
10318 encoder: &mut fidl::encoding::Encoder<'_, D>,
10319 offset: usize,
10320 _depth: fidl::encoding::Depth,
10321 ) -> fidl::Result<()> {
10322 encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10323 fidl::encoding::Encode::<AudioRendererSetUsage2Request, D>::encode(
10325 (<AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage2),),
10326 encoder,
10327 offset,
10328 _depth,
10329 )
10330 }
10331 }
10332 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage2, D>>
10333 fidl::encoding::Encode<AudioRendererSetUsage2Request, D> for (T0,)
10334 {
10335 #[inline]
10336 unsafe fn encode(
10337 self,
10338 encoder: &mut fidl::encoding::Encoder<'_, D>,
10339 offset: usize,
10340 depth: fidl::encoding::Depth,
10341 ) -> fidl::Result<()> {
10342 encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10343 self.0.encode(encoder, offset + 0, depth)?;
10347 Ok(())
10348 }
10349 }
10350
10351 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10352 for AudioRendererSetUsage2Request
10353 {
10354 #[inline(always)]
10355 fn new_empty() -> Self {
10356 Self { usage2: fidl::new_empty!(AudioRenderUsage2, D) }
10357 }
10358
10359 #[inline]
10360 unsafe fn decode(
10361 &mut self,
10362 decoder: &mut fidl::encoding::Decoder<'_, D>,
10363 offset: usize,
10364 _depth: fidl::encoding::Depth,
10365 ) -> fidl::Result<()> {
10366 decoder.debug_check_bounds::<Self>(offset);
10367 fidl::decode!(AudioRenderUsage2, D, &mut self.usage2, decoder, offset + 0, _depth)?;
10369 Ok(())
10370 }
10371 }
10372
10373 impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsageRequest {
10374 type Borrowed<'a> = &'a Self;
10375 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10376 value
10377 }
10378 }
10379
10380 unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsageRequest {
10381 type Owned = Self;
10382
10383 #[inline(always)]
10384 fn inline_align(_context: fidl::encoding::Context) -> usize {
10385 4
10386 }
10387
10388 #[inline(always)]
10389 fn inline_size(_context: fidl::encoding::Context) -> usize {
10390 4
10391 }
10392 }
10393
10394 unsafe impl<D: fidl::encoding::ResourceDialect>
10395 fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for &AudioRendererSetUsageRequest
10396 {
10397 #[inline]
10398 unsafe fn encode(
10399 self,
10400 encoder: &mut fidl::encoding::Encoder<'_, D>,
10401 offset: usize,
10402 _depth: fidl::encoding::Depth,
10403 ) -> fidl::Result<()> {
10404 encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10405 fidl::encoding::Encode::<AudioRendererSetUsageRequest, D>::encode(
10407 (<AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
10408 encoder,
10409 offset,
10410 _depth,
10411 )
10412 }
10413 }
10414 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage, D>>
10415 fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for (T0,)
10416 {
10417 #[inline]
10418 unsafe fn encode(
10419 self,
10420 encoder: &mut fidl::encoding::Encoder<'_, D>,
10421 offset: usize,
10422 depth: fidl::encoding::Depth,
10423 ) -> fidl::Result<()> {
10424 encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10425 self.0.encode(encoder, offset + 0, depth)?;
10429 Ok(())
10430 }
10431 }
10432
10433 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10434 for AudioRendererSetUsageRequest
10435 {
10436 #[inline(always)]
10437 fn new_empty() -> Self {
10438 Self { usage: fidl::new_empty!(AudioRenderUsage, D) }
10439 }
10440
10441 #[inline]
10442 unsafe fn decode(
10443 &mut self,
10444 decoder: &mut fidl::encoding::Decoder<'_, D>,
10445 offset: usize,
10446 _depth: fidl::encoding::Depth,
10447 ) -> fidl::Result<()> {
10448 decoder.debug_check_bounds::<Self>(offset);
10449 fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
10451 Ok(())
10452 }
10453 }
10454
10455 impl fidl::encoding::ValueTypeMarker for AudioStreamType {
10456 type Borrowed<'a> = &'a Self;
10457 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10458 value
10459 }
10460 }
10461
10462 unsafe impl fidl::encoding::TypeMarker for AudioStreamType {
10463 type Owned = Self;
10464
10465 #[inline(always)]
10466 fn inline_align(_context: fidl::encoding::Context) -> usize {
10467 4
10468 }
10469
10470 #[inline(always)]
10471 fn inline_size(_context: fidl::encoding::Context) -> usize {
10472 12
10473 }
10474 }
10475
10476 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioStreamType, D>
10477 for &AudioStreamType
10478 {
10479 #[inline]
10480 unsafe fn encode(
10481 self,
10482 encoder: &mut fidl::encoding::Encoder<'_, D>,
10483 offset: usize,
10484 _depth: fidl::encoding::Depth,
10485 ) -> fidl::Result<()> {
10486 encoder.debug_check_bounds::<AudioStreamType>(offset);
10487 fidl::encoding::Encode::<AudioStreamType, D>::encode(
10489 (
10490 <AudioSampleFormat as fidl::encoding::ValueTypeMarker>::borrow(
10491 &self.sample_format,
10492 ),
10493 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.channels),
10494 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
10495 ),
10496 encoder,
10497 offset,
10498 _depth,
10499 )
10500 }
10501 }
10502 unsafe impl<
10503 D: fidl::encoding::ResourceDialect,
10504 T0: fidl::encoding::Encode<AudioSampleFormat, D>,
10505 T1: fidl::encoding::Encode<u32, D>,
10506 T2: fidl::encoding::Encode<u32, D>,
10507 > fidl::encoding::Encode<AudioStreamType, D> for (T0, T1, T2)
10508 {
10509 #[inline]
10510 unsafe fn encode(
10511 self,
10512 encoder: &mut fidl::encoding::Encoder<'_, D>,
10513 offset: usize,
10514 depth: fidl::encoding::Depth,
10515 ) -> fidl::Result<()> {
10516 encoder.debug_check_bounds::<AudioStreamType>(offset);
10517 self.0.encode(encoder, offset + 0, depth)?;
10521 self.1.encode(encoder, offset + 4, depth)?;
10522 self.2.encode(encoder, offset + 8, depth)?;
10523 Ok(())
10524 }
10525 }
10526
10527 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioStreamType {
10528 #[inline(always)]
10529 fn new_empty() -> Self {
10530 Self {
10531 sample_format: fidl::new_empty!(AudioSampleFormat, D),
10532 channels: fidl::new_empty!(u32, D),
10533 frames_per_second: fidl::new_empty!(u32, D),
10534 }
10535 }
10536
10537 #[inline]
10538 unsafe fn decode(
10539 &mut self,
10540 decoder: &mut fidl::encoding::Decoder<'_, D>,
10541 offset: usize,
10542 _depth: fidl::encoding::Depth,
10543 ) -> fidl::Result<()> {
10544 decoder.debug_check_bounds::<Self>(offset);
10545 fidl::decode!(
10547 AudioSampleFormat,
10548 D,
10549 &mut self.sample_format,
10550 decoder,
10551 offset + 0,
10552 _depth
10553 )?;
10554 fidl::decode!(u32, D, &mut self.channels, decoder, offset + 4, _depth)?;
10555 fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
10556 Ok(())
10557 }
10558 }
10559
10560 impl fidl::encoding::ValueTypeMarker for Compression {
10561 type Borrowed<'a> = &'a Self;
10562 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10563 value
10564 }
10565 }
10566
10567 unsafe impl fidl::encoding::TypeMarker for Compression {
10568 type Owned = Self;
10569
10570 #[inline(always)]
10571 fn inline_align(_context: fidl::encoding::Context) -> usize {
10572 8
10573 }
10574
10575 #[inline(always)]
10576 fn inline_size(_context: fidl::encoding::Context) -> usize {
10577 32
10578 }
10579 }
10580
10581 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Compression, D>
10582 for &Compression
10583 {
10584 #[inline]
10585 unsafe fn encode(
10586 self,
10587 encoder: &mut fidl::encoding::Encoder<'_, D>,
10588 offset: usize,
10589 _depth: fidl::encoding::Depth,
10590 ) -> fidl::Result<()> {
10591 encoder.debug_check_bounds::<Compression>(offset);
10592 fidl::encoding::Encode::<Compression, D>::encode(
10594 (
10595 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
10596 <fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
10597 ),
10598 encoder, offset, _depth
10599 )
10600 }
10601 }
10602 unsafe impl<
10603 D: fidl::encoding::ResourceDialect,
10604 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
10605 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>, D>,
10606 > fidl::encoding::Encode<Compression, D> for (T0, T1)
10607 {
10608 #[inline]
10609 unsafe fn encode(
10610 self,
10611 encoder: &mut fidl::encoding::Encoder<'_, D>,
10612 offset: usize,
10613 depth: fidl::encoding::Depth,
10614 ) -> fidl::Result<()> {
10615 encoder.debug_check_bounds::<Compression>(offset);
10616 self.0.encode(encoder, offset + 0, depth)?;
10620 self.1.encode(encoder, offset + 16, depth)?;
10621 Ok(())
10622 }
10623 }
10624
10625 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Compression {
10626 #[inline(always)]
10627 fn new_empty() -> Self {
10628 Self {
10629 type_: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
10630 parameters: fidl::new_empty!(
10631 fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10632 D
10633 ),
10634 }
10635 }
10636
10637 #[inline]
10638 unsafe fn decode(
10639 &mut self,
10640 decoder: &mut fidl::encoding::Decoder<'_, D>,
10641 offset: usize,
10642 _depth: fidl::encoding::Depth,
10643 ) -> fidl::Result<()> {
10644 decoder.debug_check_bounds::<Self>(offset);
10645 fidl::decode!(
10647 fidl::encoding::BoundedString<256>,
10648 D,
10649 &mut self.type_,
10650 decoder,
10651 offset + 0,
10652 _depth
10653 )?;
10654 fidl::decode!(
10655 fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10656 D,
10657 &mut self.parameters,
10658 decoder,
10659 offset + 16,
10660 _depth
10661 )?;
10662 Ok(())
10663 }
10664 }
10665
10666 impl fidl::encoding::ValueTypeMarker for EncryptionPattern {
10667 type Borrowed<'a> = &'a Self;
10668 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10669 value
10670 }
10671 }
10672
10673 unsafe impl fidl::encoding::TypeMarker for EncryptionPattern {
10674 type Owned = Self;
10675
10676 #[inline(always)]
10677 fn inline_align(_context: fidl::encoding::Context) -> usize {
10678 4
10679 }
10680
10681 #[inline(always)]
10682 fn inline_size(_context: fidl::encoding::Context) -> usize {
10683 8
10684 }
10685 #[inline(always)]
10686 fn encode_is_copy() -> bool {
10687 true
10688 }
10689
10690 #[inline(always)]
10691 fn decode_is_copy() -> bool {
10692 true
10693 }
10694 }
10695
10696 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptionPattern, D>
10697 for &EncryptionPattern
10698 {
10699 #[inline]
10700 unsafe fn encode(
10701 self,
10702 encoder: &mut fidl::encoding::Encoder<'_, D>,
10703 offset: usize,
10704 _depth: fidl::encoding::Depth,
10705 ) -> fidl::Result<()> {
10706 encoder.debug_check_bounds::<EncryptionPattern>(offset);
10707 unsafe {
10708 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10710 (buf_ptr as *mut EncryptionPattern)
10711 .write_unaligned((self as *const EncryptionPattern).read());
10712 }
10715 Ok(())
10716 }
10717 }
10718 unsafe impl<
10719 D: fidl::encoding::ResourceDialect,
10720 T0: fidl::encoding::Encode<u32, D>,
10721 T1: fidl::encoding::Encode<u32, D>,
10722 > fidl::encoding::Encode<EncryptionPattern, D> for (T0, T1)
10723 {
10724 #[inline]
10725 unsafe fn encode(
10726 self,
10727 encoder: &mut fidl::encoding::Encoder<'_, D>,
10728 offset: usize,
10729 depth: fidl::encoding::Depth,
10730 ) -> fidl::Result<()> {
10731 encoder.debug_check_bounds::<EncryptionPattern>(offset);
10732 self.0.encode(encoder, offset + 0, depth)?;
10736 self.1.encode(encoder, offset + 4, depth)?;
10737 Ok(())
10738 }
10739 }
10740
10741 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptionPattern {
10742 #[inline(always)]
10743 fn new_empty() -> Self {
10744 Self {
10745 clear_blocks: fidl::new_empty!(u32, D),
10746 encrypted_blocks: fidl::new_empty!(u32, D),
10747 }
10748 }
10749
10750 #[inline]
10751 unsafe fn decode(
10752 &mut self,
10753 decoder: &mut fidl::encoding::Decoder<'_, D>,
10754 offset: usize,
10755 _depth: fidl::encoding::Depth,
10756 ) -> fidl::Result<()> {
10757 decoder.debug_check_bounds::<Self>(offset);
10758 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10759 unsafe {
10762 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10763 }
10764 Ok(())
10765 }
10766 }
10767
10768 impl fidl::encoding::ValueTypeMarker for Metadata {
10769 type Borrowed<'a> = &'a Self;
10770 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10771 value
10772 }
10773 }
10774
10775 unsafe impl fidl::encoding::TypeMarker for Metadata {
10776 type Owned = Self;
10777
10778 #[inline(always)]
10779 fn inline_align(_context: fidl::encoding::Context) -> usize {
10780 8
10781 }
10782
10783 #[inline(always)]
10784 fn inline_size(_context: fidl::encoding::Context) -> usize {
10785 16
10786 }
10787 }
10788
10789 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metadata, D> for &Metadata {
10790 #[inline]
10791 unsafe fn encode(
10792 self,
10793 encoder: &mut fidl::encoding::Encoder<'_, D>,
10794 offset: usize,
10795 _depth: fidl::encoding::Depth,
10796 ) -> fidl::Result<()> {
10797 encoder.debug_check_bounds::<Metadata>(offset);
10798 fidl::encoding::Encode::<Metadata, D>::encode(
10800 (
10801 <fidl::encoding::UnboundedVector<Property> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
10802 ),
10803 encoder, offset, _depth
10804 )
10805 }
10806 }
10807 unsafe impl<
10808 D: fidl::encoding::ResourceDialect,
10809 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Property>, D>,
10810 > fidl::encoding::Encode<Metadata, D> for (T0,)
10811 {
10812 #[inline]
10813 unsafe fn encode(
10814 self,
10815 encoder: &mut fidl::encoding::Encoder<'_, D>,
10816 offset: usize,
10817 depth: fidl::encoding::Depth,
10818 ) -> fidl::Result<()> {
10819 encoder.debug_check_bounds::<Metadata>(offset);
10820 self.0.encode(encoder, offset + 0, depth)?;
10824 Ok(())
10825 }
10826 }
10827
10828 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metadata {
10829 #[inline(always)]
10830 fn new_empty() -> Self {
10831 Self { properties: fidl::new_empty!(fidl::encoding::UnboundedVector<Property>, D) }
10832 }
10833
10834 #[inline]
10835 unsafe fn decode(
10836 &mut self,
10837 decoder: &mut fidl::encoding::Decoder<'_, D>,
10838 offset: usize,
10839 _depth: fidl::encoding::Depth,
10840 ) -> fidl::Result<()> {
10841 decoder.debug_check_bounds::<Self>(offset);
10842 fidl::decode!(
10844 fidl::encoding::UnboundedVector<Property>,
10845 D,
10846 &mut self.properties,
10847 decoder,
10848 offset + 0,
10849 _depth
10850 )?;
10851 Ok(())
10852 }
10853 }
10854
10855 impl fidl::encoding::ValueTypeMarker for Parameter {
10856 type Borrowed<'a> = &'a Self;
10857 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10858 value
10859 }
10860 }
10861
10862 unsafe impl fidl::encoding::TypeMarker for Parameter {
10863 type Owned = Self;
10864
10865 #[inline(always)]
10866 fn inline_align(_context: fidl::encoding::Context) -> usize {
10867 8
10868 }
10869
10870 #[inline(always)]
10871 fn inline_size(_context: fidl::encoding::Context) -> usize {
10872 48
10873 }
10874 }
10875
10876 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
10877 for &Parameter
10878 {
10879 #[inline]
10880 unsafe fn encode(
10881 self,
10882 encoder: &mut fidl::encoding::Encoder<'_, D>,
10883 offset: usize,
10884 _depth: fidl::encoding::Depth,
10885 ) -> fidl::Result<()> {
10886 encoder.debug_check_bounds::<Parameter>(offset);
10887 fidl::encoding::Encode::<Parameter, D>::encode(
10889 (
10890 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
10891 &self.scope,
10892 ),
10893 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
10894 &self.name,
10895 ),
10896 <Value as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
10897 ),
10898 encoder,
10899 offset,
10900 _depth,
10901 )
10902 }
10903 }
10904 unsafe impl<
10905 D: fidl::encoding::ResourceDialect,
10906 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
10907 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
10908 T2: fidl::encoding::Encode<Value, D>,
10909 > fidl::encoding::Encode<Parameter, D> for (T0, T1, T2)
10910 {
10911 #[inline]
10912 unsafe fn encode(
10913 self,
10914 encoder: &mut fidl::encoding::Encoder<'_, D>,
10915 offset: usize,
10916 depth: fidl::encoding::Depth,
10917 ) -> fidl::Result<()> {
10918 encoder.debug_check_bounds::<Parameter>(offset);
10919 self.0.encode(encoder, offset + 0, depth)?;
10923 self.1.encode(encoder, offset + 16, depth)?;
10924 self.2.encode(encoder, offset + 32, depth)?;
10925 Ok(())
10926 }
10927 }
10928
10929 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
10930 #[inline(always)]
10931 fn new_empty() -> Self {
10932 Self {
10933 scope: fidl::new_empty!(fidl::encoding::UnboundedString, D),
10934 name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
10935 value: fidl::new_empty!(Value, D),
10936 }
10937 }
10938
10939 #[inline]
10940 unsafe fn decode(
10941 &mut self,
10942 decoder: &mut fidl::encoding::Decoder<'_, D>,
10943 offset: usize,
10944 _depth: fidl::encoding::Depth,
10945 ) -> fidl::Result<()> {
10946 decoder.debug_check_bounds::<Self>(offset);
10947 fidl::decode!(
10949 fidl::encoding::UnboundedString,
10950 D,
10951 &mut self.scope,
10952 decoder,
10953 offset + 0,
10954 _depth
10955 )?;
10956 fidl::decode!(
10957 fidl::encoding::UnboundedString,
10958 D,
10959 &mut self.name,
10960 decoder,
10961 offset + 16,
10962 _depth
10963 )?;
10964 fidl::decode!(Value, D, &mut self.value, decoder, offset + 32, _depth)?;
10965 Ok(())
10966 }
10967 }
10968
10969 impl fidl::encoding::ValueTypeMarker for PcmFormat {
10970 type Borrowed<'a> = &'a Self;
10971 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10972 value
10973 }
10974 }
10975
10976 unsafe impl fidl::encoding::TypeMarker for PcmFormat {
10977 type Owned = Self;
10978
10979 #[inline(always)]
10980 fn inline_align(_context: fidl::encoding::Context) -> usize {
10981 8
10982 }
10983
10984 #[inline(always)]
10985 fn inline_size(_context: fidl::encoding::Context) -> usize {
10986 32
10987 }
10988 }
10989
10990 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormat, D>
10991 for &PcmFormat
10992 {
10993 #[inline]
10994 unsafe fn encode(
10995 self,
10996 encoder: &mut fidl::encoding::Encoder<'_, D>,
10997 offset: usize,
10998 _depth: fidl::encoding::Depth,
10999 ) -> fidl::Result<()> {
11000 encoder.debug_check_bounds::<PcmFormat>(offset);
11001 fidl::encoding::Encode::<PcmFormat, D>::encode(
11003 (
11004 <AudioPcmMode as fidl::encoding::ValueTypeMarker>::borrow(&self.pcm_mode),
11005 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.bits_per_sample),
11006 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
11007 <fidl::encoding::Vector<AudioChannelId, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_map),
11008 ),
11009 encoder, offset, _depth
11010 )
11011 }
11012 }
11013 unsafe impl<
11014 D: fidl::encoding::ResourceDialect,
11015 T0: fidl::encoding::Encode<AudioPcmMode, D>,
11016 T1: fidl::encoding::Encode<u32, D>,
11017 T2: fidl::encoding::Encode<u32, D>,
11018 T3: fidl::encoding::Encode<fidl::encoding::Vector<AudioChannelId, 16>, D>,
11019 > fidl::encoding::Encode<PcmFormat, D> for (T0, T1, T2, T3)
11020 {
11021 #[inline]
11022 unsafe fn encode(
11023 self,
11024 encoder: &mut fidl::encoding::Encoder<'_, D>,
11025 offset: usize,
11026 depth: fidl::encoding::Depth,
11027 ) -> fidl::Result<()> {
11028 encoder.debug_check_bounds::<PcmFormat>(offset);
11029 unsafe {
11032 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11033 (ptr as *mut u64).write_unaligned(0);
11034 }
11035 self.0.encode(encoder, offset + 0, depth)?;
11037 self.1.encode(encoder, offset + 4, depth)?;
11038 self.2.encode(encoder, offset + 8, depth)?;
11039 self.3.encode(encoder, offset + 16, depth)?;
11040 Ok(())
11041 }
11042 }
11043
11044 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormat {
11045 #[inline(always)]
11046 fn new_empty() -> Self {
11047 Self {
11048 pcm_mode: fidl::new_empty!(AudioPcmMode, D),
11049 bits_per_sample: fidl::new_empty!(u32, D),
11050 frames_per_second: fidl::new_empty!(u32, D),
11051 channel_map: fidl::new_empty!(fidl::encoding::Vector<AudioChannelId, 16>, D),
11052 }
11053 }
11054
11055 #[inline]
11056 unsafe fn decode(
11057 &mut self,
11058 decoder: &mut fidl::encoding::Decoder<'_, D>,
11059 offset: usize,
11060 _depth: fidl::encoding::Depth,
11061 ) -> fidl::Result<()> {
11062 decoder.debug_check_bounds::<Self>(offset);
11063 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11065 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11066 let mask = 0xffffffff00000000u64;
11067 let maskedval = padval & mask;
11068 if maskedval != 0 {
11069 return Err(fidl::Error::NonZeroPadding {
11070 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11071 });
11072 }
11073 fidl::decode!(AudioPcmMode, D, &mut self.pcm_mode, decoder, offset + 0, _depth)?;
11074 fidl::decode!(u32, D, &mut self.bits_per_sample, decoder, offset + 4, _depth)?;
11075 fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
11076 fidl::decode!(fidl::encoding::Vector<AudioChannelId, 16>, D, &mut self.channel_map, decoder, offset + 16, _depth)?;
11077 Ok(())
11078 }
11079 }
11080
11081 impl fidl::encoding::ValueTypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11082 type Borrowed<'a> = &'a Self;
11083 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11084 value
11085 }
11086 }
11087
11088 unsafe impl fidl::encoding::TypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11089 type Owned = Self;
11090
11091 #[inline(always)]
11092 fn inline_align(_context: fidl::encoding::Context) -> usize {
11093 8
11094 }
11095
11096 #[inline(always)]
11097 fn inline_size(_context: fidl::encoding::Context) -> usize {
11098 16
11099 }
11100 #[inline(always)]
11101 fn encode_is_copy() -> bool {
11102 true
11103 }
11104
11105 #[inline(always)]
11106 fn decode_is_copy() -> bool {
11107 true
11108 }
11109 }
11110
11111 unsafe impl<D: fidl::encoding::ResourceDialect>
11112 fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11113 for &ProfileProviderRegisterHandlerWithCapacityResponse
11114 {
11115 #[inline]
11116 unsafe fn encode(
11117 self,
11118 encoder: &mut fidl::encoding::Encoder<'_, D>,
11119 offset: usize,
11120 _depth: fidl::encoding::Depth,
11121 ) -> fidl::Result<()> {
11122 encoder
11123 .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11124 unsafe {
11125 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11127 (buf_ptr as *mut ProfileProviderRegisterHandlerWithCapacityResponse)
11128 .write_unaligned(
11129 (self as *const ProfileProviderRegisterHandlerWithCapacityResponse).read(),
11130 );
11131 }
11134 Ok(())
11135 }
11136 }
11137 unsafe impl<
11138 D: fidl::encoding::ResourceDialect,
11139 T0: fidl::encoding::Encode<i64, D>,
11140 T1: fidl::encoding::Encode<i64, D>,
11141 > fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11142 for (T0, T1)
11143 {
11144 #[inline]
11145 unsafe fn encode(
11146 self,
11147 encoder: &mut fidl::encoding::Encoder<'_, D>,
11148 offset: usize,
11149 depth: fidl::encoding::Depth,
11150 ) -> fidl::Result<()> {
11151 encoder
11152 .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11153 self.0.encode(encoder, offset + 0, depth)?;
11157 self.1.encode(encoder, offset + 8, depth)?;
11158 Ok(())
11159 }
11160 }
11161
11162 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11163 for ProfileProviderRegisterHandlerWithCapacityResponse
11164 {
11165 #[inline(always)]
11166 fn new_empty() -> Self {
11167 Self { period: fidl::new_empty!(i64, D), capacity: fidl::new_empty!(i64, D) }
11168 }
11169
11170 #[inline]
11171 unsafe fn decode(
11172 &mut self,
11173 decoder: &mut fidl::encoding::Decoder<'_, D>,
11174 offset: usize,
11175 _depth: fidl::encoding::Depth,
11176 ) -> fidl::Result<()> {
11177 decoder.debug_check_bounds::<Self>(offset);
11178 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11179 unsafe {
11182 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
11183 }
11184 Ok(())
11185 }
11186 }
11187
11188 impl fidl::encoding::ValueTypeMarker for Property {
11189 type Borrowed<'a> = &'a Self;
11190 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11191 value
11192 }
11193 }
11194
11195 unsafe impl fidl::encoding::TypeMarker for Property {
11196 type Owned = Self;
11197
11198 #[inline(always)]
11199 fn inline_align(_context: fidl::encoding::Context) -> usize {
11200 8
11201 }
11202
11203 #[inline(always)]
11204 fn inline_size(_context: fidl::encoding::Context) -> usize {
11205 32
11206 }
11207 }
11208
11209 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Property, D> for &Property {
11210 #[inline]
11211 unsafe fn encode(
11212 self,
11213 encoder: &mut fidl::encoding::Encoder<'_, D>,
11214 offset: usize,
11215 _depth: fidl::encoding::Depth,
11216 ) -> fidl::Result<()> {
11217 encoder.debug_check_bounds::<Property>(offset);
11218 fidl::encoding::Encode::<Property, D>::encode(
11220 (
11221 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11222 &self.label,
11223 ),
11224 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11225 &self.value,
11226 ),
11227 ),
11228 encoder,
11229 offset,
11230 _depth,
11231 )
11232 }
11233 }
11234 unsafe impl<
11235 D: fidl::encoding::ResourceDialect,
11236 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11237 T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11238 > fidl::encoding::Encode<Property, D> for (T0, T1)
11239 {
11240 #[inline]
11241 unsafe fn encode(
11242 self,
11243 encoder: &mut fidl::encoding::Encoder<'_, D>,
11244 offset: usize,
11245 depth: fidl::encoding::Depth,
11246 ) -> fidl::Result<()> {
11247 encoder.debug_check_bounds::<Property>(offset);
11248 self.0.encode(encoder, offset + 0, depth)?;
11252 self.1.encode(encoder, offset + 16, depth)?;
11253 Ok(())
11254 }
11255 }
11256
11257 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Property {
11258 #[inline(always)]
11259 fn new_empty() -> Self {
11260 Self {
11261 label: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11262 value: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11263 }
11264 }
11265
11266 #[inline]
11267 unsafe fn decode(
11268 &mut self,
11269 decoder: &mut fidl::encoding::Decoder<'_, D>,
11270 offset: usize,
11271 _depth: fidl::encoding::Depth,
11272 ) -> fidl::Result<()> {
11273 decoder.debug_check_bounds::<Self>(offset);
11274 fidl::decode!(
11276 fidl::encoding::UnboundedString,
11277 D,
11278 &mut self.label,
11279 decoder,
11280 offset + 0,
11281 _depth
11282 )?;
11283 fidl::decode!(
11284 fidl::encoding::UnboundedString,
11285 D,
11286 &mut self.value,
11287 decoder,
11288 offset + 16,
11289 _depth
11290 )?;
11291 Ok(())
11292 }
11293 }
11294
11295 impl fidl::encoding::ValueTypeMarker for SbcEncoderSettings {
11296 type Borrowed<'a> = &'a Self;
11297 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11298 value
11299 }
11300 }
11301
11302 unsafe impl fidl::encoding::TypeMarker for SbcEncoderSettings {
11303 type Owned = Self;
11304
11305 #[inline(always)]
11306 fn inline_align(_context: fidl::encoding::Context) -> usize {
11307 8
11308 }
11309
11310 #[inline(always)]
11311 fn inline_size(_context: fidl::encoding::Context) -> usize {
11312 24
11313 }
11314 }
11315
11316 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SbcEncoderSettings, D>
11317 for &SbcEncoderSettings
11318 {
11319 #[inline]
11320 unsafe fn encode(
11321 self,
11322 encoder: &mut fidl::encoding::Encoder<'_, D>,
11323 offset: usize,
11324 _depth: fidl::encoding::Depth,
11325 ) -> fidl::Result<()> {
11326 encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11327 fidl::encoding::Encode::<SbcEncoderSettings, D>::encode(
11329 (
11330 <SbcSubBands as fidl::encoding::ValueTypeMarker>::borrow(&self.sub_bands),
11331 <SbcAllocation as fidl::encoding::ValueTypeMarker>::borrow(&self.allocation),
11332 <SbcBlockCount as fidl::encoding::ValueTypeMarker>::borrow(&self.block_count),
11333 <SbcChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
11334 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_pool),
11335 ),
11336 encoder,
11337 offset,
11338 _depth,
11339 )
11340 }
11341 }
11342 unsafe impl<
11343 D: fidl::encoding::ResourceDialect,
11344 T0: fidl::encoding::Encode<SbcSubBands, D>,
11345 T1: fidl::encoding::Encode<SbcAllocation, D>,
11346 T2: fidl::encoding::Encode<SbcBlockCount, D>,
11347 T3: fidl::encoding::Encode<SbcChannelMode, D>,
11348 T4: fidl::encoding::Encode<u64, D>,
11349 > fidl::encoding::Encode<SbcEncoderSettings, D> for (T0, T1, T2, T3, T4)
11350 {
11351 #[inline]
11352 unsafe fn encode(
11353 self,
11354 encoder: &mut fidl::encoding::Encoder<'_, D>,
11355 offset: usize,
11356 depth: fidl::encoding::Depth,
11357 ) -> fidl::Result<()> {
11358 encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11359 self.0.encode(encoder, offset + 0, depth)?;
11363 self.1.encode(encoder, offset + 4, depth)?;
11364 self.2.encode(encoder, offset + 8, depth)?;
11365 self.3.encode(encoder, offset + 12, depth)?;
11366 self.4.encode(encoder, offset + 16, depth)?;
11367 Ok(())
11368 }
11369 }
11370
11371 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcEncoderSettings {
11372 #[inline(always)]
11373 fn new_empty() -> Self {
11374 Self {
11375 sub_bands: fidl::new_empty!(SbcSubBands, D),
11376 allocation: fidl::new_empty!(SbcAllocation, D),
11377 block_count: fidl::new_empty!(SbcBlockCount, D),
11378 channel_mode: fidl::new_empty!(SbcChannelMode, D),
11379 bit_pool: fidl::new_empty!(u64, D),
11380 }
11381 }
11382
11383 #[inline]
11384 unsafe fn decode(
11385 &mut self,
11386 decoder: &mut fidl::encoding::Decoder<'_, D>,
11387 offset: usize,
11388 _depth: fidl::encoding::Depth,
11389 ) -> fidl::Result<()> {
11390 decoder.debug_check_bounds::<Self>(offset);
11391 fidl::decode!(SbcSubBands, D, &mut self.sub_bands, decoder, offset + 0, _depth)?;
11393 fidl::decode!(SbcAllocation, D, &mut self.allocation, decoder, offset + 4, _depth)?;
11394 fidl::decode!(SbcBlockCount, D, &mut self.block_count, decoder, offset + 8, _depth)?;
11395 fidl::decode!(SbcChannelMode, D, &mut self.channel_mode, decoder, offset + 12, _depth)?;
11396 fidl::decode!(u64, D, &mut self.bit_pool, decoder, offset + 16, _depth)?;
11397 Ok(())
11398 }
11399 }
11400
11401 impl fidl::encoding::ValueTypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11402 type Borrowed<'a> = &'a Self;
11403 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11404 value
11405 }
11406 }
11407
11408 unsafe impl fidl::encoding::TypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11409 type Owned = Self;
11410
11411 #[inline(always)]
11412 fn inline_align(_context: fidl::encoding::Context) -> usize {
11413 4
11414 }
11415
11416 #[inline(always)]
11417 fn inline_size(_context: fidl::encoding::Context) -> usize {
11418 4
11419 }
11420 #[inline(always)]
11421 fn encode_is_copy() -> bool {
11422 true
11423 }
11424
11425 #[inline(always)]
11426 fn decode_is_copy() -> bool {
11427 true
11428 }
11429 }
11430
11431 unsafe impl<D: fidl::encoding::ResourceDialect>
11432 fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D>
11433 for &StreamBufferSetRemovePayloadBufferRequest
11434 {
11435 #[inline]
11436 unsafe fn encode(
11437 self,
11438 encoder: &mut fidl::encoding::Encoder<'_, D>,
11439 offset: usize,
11440 _depth: fidl::encoding::Depth,
11441 ) -> fidl::Result<()> {
11442 encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11443 unsafe {
11444 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11446 (buf_ptr as *mut StreamBufferSetRemovePayloadBufferRequest).write_unaligned(
11447 (self as *const StreamBufferSetRemovePayloadBufferRequest).read(),
11448 );
11449 }
11452 Ok(())
11453 }
11454 }
11455 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
11456 fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D> for (T0,)
11457 {
11458 #[inline]
11459 unsafe fn encode(
11460 self,
11461 encoder: &mut fidl::encoding::Encoder<'_, D>,
11462 offset: usize,
11463 depth: fidl::encoding::Depth,
11464 ) -> fidl::Result<()> {
11465 encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11466 self.0.encode(encoder, offset + 0, depth)?;
11470 Ok(())
11471 }
11472 }
11473
11474 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11475 for StreamBufferSetRemovePayloadBufferRequest
11476 {
11477 #[inline(always)]
11478 fn new_empty() -> Self {
11479 Self { id: fidl::new_empty!(u32, D) }
11480 }
11481
11482 #[inline]
11483 unsafe fn decode(
11484 &mut self,
11485 decoder: &mut fidl::encoding::Decoder<'_, D>,
11486 offset: usize,
11487 _depth: fidl::encoding::Depth,
11488 ) -> fidl::Result<()> {
11489 decoder.debug_check_bounds::<Self>(offset);
11490 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11491 unsafe {
11494 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
11495 }
11496 Ok(())
11497 }
11498 }
11499
11500 impl fidl::encoding::ValueTypeMarker for StreamPacket {
11501 type Borrowed<'a> = &'a Self;
11502 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11503 value
11504 }
11505 }
11506
11507 unsafe impl fidl::encoding::TypeMarker for StreamPacket {
11508 type Owned = Self;
11509
11510 #[inline(always)]
11511 fn inline_align(_context: fidl::encoding::Context) -> usize {
11512 8
11513 }
11514
11515 #[inline(always)]
11516 fn inline_size(_context: fidl::encoding::Context) -> usize {
11517 56
11518 }
11519 }
11520
11521 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamPacket, D>
11522 for &StreamPacket
11523 {
11524 #[inline]
11525 unsafe fn encode(
11526 self,
11527 encoder: &mut fidl::encoding::Encoder<'_, D>,
11528 offset: usize,
11529 _depth: fidl::encoding::Depth,
11530 ) -> fidl::Result<()> {
11531 encoder.debug_check_bounds::<StreamPacket>(offset);
11532 unsafe {
11533 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11535 (buf_ptr as *mut StreamPacket)
11536 .write_unaligned((self as *const StreamPacket).read());
11537 let padding_ptr = buf_ptr.offset(8) as *mut u64;
11540 let padding_mask = 0xffffffff00000000u64;
11541 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11542 let padding_ptr = buf_ptr.offset(32) as *mut u64;
11543 let padding_mask = 0xffffffff00000000u64;
11544 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11545 }
11546 Ok(())
11547 }
11548 }
11549 unsafe impl<
11550 D: fidl::encoding::ResourceDialect,
11551 T0: fidl::encoding::Encode<i64, D>,
11552 T1: fidl::encoding::Encode<u32, D>,
11553 T2: fidl::encoding::Encode<u64, D>,
11554 T3: fidl::encoding::Encode<u64, D>,
11555 T4: fidl::encoding::Encode<u32, D>,
11556 T5: fidl::encoding::Encode<u64, D>,
11557 T6: fidl::encoding::Encode<u64, D>,
11558 > fidl::encoding::Encode<StreamPacket, D> for (T0, T1, T2, T3, T4, T5, T6)
11559 {
11560 #[inline]
11561 unsafe fn encode(
11562 self,
11563 encoder: &mut fidl::encoding::Encoder<'_, D>,
11564 offset: usize,
11565 depth: fidl::encoding::Depth,
11566 ) -> fidl::Result<()> {
11567 encoder.debug_check_bounds::<StreamPacket>(offset);
11568 unsafe {
11571 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11572 (ptr as *mut u64).write_unaligned(0);
11573 }
11574 unsafe {
11575 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
11576 (ptr as *mut u64).write_unaligned(0);
11577 }
11578 self.0.encode(encoder, offset + 0, depth)?;
11580 self.1.encode(encoder, offset + 8, depth)?;
11581 self.2.encode(encoder, offset + 16, depth)?;
11582 self.3.encode(encoder, offset + 24, depth)?;
11583 self.4.encode(encoder, offset + 32, depth)?;
11584 self.5.encode(encoder, offset + 40, depth)?;
11585 self.6.encode(encoder, offset + 48, depth)?;
11586 Ok(())
11587 }
11588 }
11589
11590 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamPacket {
11591 #[inline(always)]
11592 fn new_empty() -> Self {
11593 Self {
11594 pts: fidl::new_empty!(i64, D),
11595 payload_buffer_id: fidl::new_empty!(u32, D),
11596 payload_offset: fidl::new_empty!(u64, D),
11597 payload_size: fidl::new_empty!(u64, D),
11598 flags: fidl::new_empty!(u32, D),
11599 buffer_config: fidl::new_empty!(u64, D),
11600 stream_segment_id: fidl::new_empty!(u64, D),
11601 }
11602 }
11603
11604 #[inline]
11605 unsafe fn decode(
11606 &mut self,
11607 decoder: &mut fidl::encoding::Decoder<'_, D>,
11608 offset: usize,
11609 _depth: fidl::encoding::Depth,
11610 ) -> fidl::Result<()> {
11611 decoder.debug_check_bounds::<Self>(offset);
11612 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11613 let ptr = unsafe { buf_ptr.offset(8) };
11615 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11616 let mask = 0xffffffff00000000u64;
11617 let maskedval = padval & mask;
11618 if maskedval != 0 {
11619 return Err(fidl::Error::NonZeroPadding {
11620 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11621 });
11622 }
11623 let ptr = unsafe { buf_ptr.offset(32) };
11624 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11625 let mask = 0xffffffff00000000u64;
11626 let maskedval = padval & mask;
11627 if maskedval != 0 {
11628 return Err(fidl::Error::NonZeroPadding {
11629 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
11630 });
11631 }
11632 unsafe {
11634 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
11635 }
11636 Ok(())
11637 }
11638 }
11639
11640 impl fidl::encoding::ValueTypeMarker for StreamProcessorCloseCurrentStreamRequest {
11641 type Borrowed<'a> = &'a Self;
11642 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11643 value
11644 }
11645 }
11646
11647 unsafe impl fidl::encoding::TypeMarker for StreamProcessorCloseCurrentStreamRequest {
11648 type Owned = Self;
11649
11650 #[inline(always)]
11651 fn inline_align(_context: fidl::encoding::Context) -> usize {
11652 8
11653 }
11654
11655 #[inline(always)]
11656 fn inline_size(_context: fidl::encoding::Context) -> usize {
11657 16
11658 }
11659 }
11660
11661 unsafe impl<D: fidl::encoding::ResourceDialect>
11662 fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D>
11663 for &StreamProcessorCloseCurrentStreamRequest
11664 {
11665 #[inline]
11666 unsafe fn encode(
11667 self,
11668 encoder: &mut fidl::encoding::Encoder<'_, D>,
11669 offset: usize,
11670 _depth: fidl::encoding::Depth,
11671 ) -> fidl::Result<()> {
11672 encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11673 fidl::encoding::Encode::<StreamProcessorCloseCurrentStreamRequest, D>::encode(
11675 (
11676 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
11677 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_input_buffers),
11678 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_output_buffers),
11679 ),
11680 encoder,
11681 offset,
11682 _depth,
11683 )
11684 }
11685 }
11686 unsafe impl<
11687 D: fidl::encoding::ResourceDialect,
11688 T0: fidl::encoding::Encode<u64, D>,
11689 T1: fidl::encoding::Encode<bool, D>,
11690 T2: fidl::encoding::Encode<bool, D>,
11691 > fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D> for (T0, T1, T2)
11692 {
11693 #[inline]
11694 unsafe fn encode(
11695 self,
11696 encoder: &mut fidl::encoding::Encoder<'_, D>,
11697 offset: usize,
11698 depth: fidl::encoding::Depth,
11699 ) -> fidl::Result<()> {
11700 encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11701 unsafe {
11704 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11705 (ptr as *mut u64).write_unaligned(0);
11706 }
11707 self.0.encode(encoder, offset + 0, depth)?;
11709 self.1.encode(encoder, offset + 8, depth)?;
11710 self.2.encode(encoder, offset + 9, depth)?;
11711 Ok(())
11712 }
11713 }
11714
11715 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11716 for StreamProcessorCloseCurrentStreamRequest
11717 {
11718 #[inline(always)]
11719 fn new_empty() -> Self {
11720 Self {
11721 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
11722 release_input_buffers: fidl::new_empty!(bool, D),
11723 release_output_buffers: fidl::new_empty!(bool, D),
11724 }
11725 }
11726
11727 #[inline]
11728 unsafe fn decode(
11729 &mut self,
11730 decoder: &mut fidl::encoding::Decoder<'_, D>,
11731 offset: usize,
11732 _depth: fidl::encoding::Depth,
11733 ) -> fidl::Result<()> {
11734 decoder.debug_check_bounds::<Self>(offset);
11735 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11737 let padval = unsafe { (ptr as *const u64).read_unaligned() };
11738 let mask = 0xffffffffffff0000u64;
11739 let maskedval = padval & mask;
11740 if maskedval != 0 {
11741 return Err(fidl::Error::NonZeroPadding {
11742 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11743 });
11744 }
11745 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
11746 fidl::decode!(bool, D, &mut self.release_input_buffers, decoder, offset + 8, _depth)?;
11747 fidl::decode!(bool, D, &mut self.release_output_buffers, decoder, offset + 9, _depth)?;
11748 Ok(())
11749 }
11750 }
11751
11752 impl fidl::encoding::ValueTypeMarker for StreamProcessorCompleteOutputBufferPartialSettingsRequest {
11753 type Borrowed<'a> = &'a Self;
11754 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11755 value
11756 }
11757 }
11758
11759 unsafe impl fidl::encoding::TypeMarker
11760 for StreamProcessorCompleteOutputBufferPartialSettingsRequest
11761 {
11762 type Owned = Self;
11763
11764 #[inline(always)]
11765 fn inline_align(_context: fidl::encoding::Context) -> usize {
11766 8
11767 }
11768
11769 #[inline(always)]
11770 fn inline_size(_context: fidl::encoding::Context) -> usize {
11771 8
11772 }
11773 #[inline(always)]
11774 fn encode_is_copy() -> bool {
11775 true
11776 }
11777
11778 #[inline(always)]
11779 fn decode_is_copy() -> bool {
11780 true
11781 }
11782 }
11783
11784 unsafe impl<D: fidl::encoding::ResourceDialect>
11785 fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
11786 for &StreamProcessorCompleteOutputBufferPartialSettingsRequest
11787 {
11788 #[inline]
11789 unsafe fn encode(
11790 self,
11791 encoder: &mut fidl::encoding::Encoder<'_, D>,
11792 offset: usize,
11793 _depth: fidl::encoding::Depth,
11794 ) -> fidl::Result<()> {
11795 encoder
11796 .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
11797 offset,
11798 );
11799 unsafe {
11800 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11802 (buf_ptr as *mut StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11803 .write_unaligned(
11804 (self as *const StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11805 .read(),
11806 );
11807 }
11810 Ok(())
11811 }
11812 }
11813 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
11814 fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
11815 for (T0,)
11816 {
11817 #[inline]
11818 unsafe fn encode(
11819 self,
11820 encoder: &mut fidl::encoding::Encoder<'_, D>,
11821 offset: usize,
11822 depth: fidl::encoding::Depth,
11823 ) -> fidl::Result<()> {
11824 encoder
11825 .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
11826 offset,
11827 );
11828 self.0.encode(encoder, offset + 0, depth)?;
11832 Ok(())
11833 }
11834 }
11835
11836 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11837 for StreamProcessorCompleteOutputBufferPartialSettingsRequest
11838 {
11839 #[inline(always)]
11840 fn new_empty() -> Self {
11841 Self { buffer_lifetime_ordinal: fidl::new_empty!(u64, D) }
11842 }
11843
11844 #[inline]
11845 unsafe fn decode(
11846 &mut self,
11847 decoder: &mut fidl::encoding::Decoder<'_, D>,
11848 offset: usize,
11849 _depth: fidl::encoding::Depth,
11850 ) -> fidl::Result<()> {
11851 decoder.debug_check_bounds::<Self>(offset);
11852 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11853 unsafe {
11856 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
11857 }
11858 Ok(())
11859 }
11860 }
11861
11862 impl fidl::encoding::ValueTypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
11863 type Borrowed<'a> = &'a Self;
11864 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11865 value
11866 }
11867 }
11868
11869 unsafe impl fidl::encoding::TypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
11870 type Owned = Self;
11871
11872 #[inline(always)]
11873 fn inline_align(_context: fidl::encoding::Context) -> usize {
11874 8
11875 }
11876
11877 #[inline(always)]
11878 fn inline_size(_context: fidl::encoding::Context) -> usize {
11879 8
11880 }
11881 #[inline(always)]
11882 fn encode_is_copy() -> bool {
11883 true
11884 }
11885
11886 #[inline(always)]
11887 fn decode_is_copy() -> bool {
11888 true
11889 }
11890 }
11891
11892 unsafe impl<D: fidl::encoding::ResourceDialect>
11893 fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D>
11894 for &StreamProcessorFlushEndOfStreamAndCloseStreamRequest
11895 {
11896 #[inline]
11897 unsafe fn encode(
11898 self,
11899 encoder: &mut fidl::encoding::Encoder<'_, D>,
11900 offset: usize,
11901 _depth: fidl::encoding::Depth,
11902 ) -> fidl::Result<()> {
11903 encoder
11904 .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
11905 unsafe {
11906 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11908 (buf_ptr as *mut StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
11909 .write_unaligned(
11910 (self as *const StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
11911 .read(),
11912 );
11913 }
11916 Ok(())
11917 }
11918 }
11919 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
11920 fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D> for (T0,)
11921 {
11922 #[inline]
11923 unsafe fn encode(
11924 self,
11925 encoder: &mut fidl::encoding::Encoder<'_, D>,
11926 offset: usize,
11927 depth: fidl::encoding::Depth,
11928 ) -> fidl::Result<()> {
11929 encoder
11930 .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
11931 self.0.encode(encoder, offset + 0, depth)?;
11935 Ok(())
11936 }
11937 }
11938
11939 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11940 for StreamProcessorFlushEndOfStreamAndCloseStreamRequest
11941 {
11942 #[inline(always)]
11943 fn new_empty() -> Self {
11944 Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
11945 }
11946
11947 #[inline]
11948 unsafe fn decode(
11949 &mut self,
11950 decoder: &mut fidl::encoding::Decoder<'_, D>,
11951 offset: usize,
11952 _depth: fidl::encoding::Depth,
11953 ) -> fidl::Result<()> {
11954 decoder.debug_check_bounds::<Self>(offset);
11955 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11956 unsafe {
11959 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
11960 }
11961 Ok(())
11962 }
11963 }
11964
11965 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnFreeInputPacketRequest {
11966 type Borrowed<'a> = &'a Self;
11967 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11968 value
11969 }
11970 }
11971
11972 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnFreeInputPacketRequest {
11973 type Owned = Self;
11974
11975 #[inline(always)]
11976 fn inline_align(_context: fidl::encoding::Context) -> usize {
11977 8
11978 }
11979
11980 #[inline(always)]
11981 fn inline_size(_context: fidl::encoding::Context) -> usize {
11982 16
11983 }
11984 }
11985
11986 unsafe impl<D: fidl::encoding::ResourceDialect>
11987 fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D>
11988 for &StreamProcessorOnFreeInputPacketRequest
11989 {
11990 #[inline]
11991 unsafe fn encode(
11992 self,
11993 encoder: &mut fidl::encoding::Encoder<'_, D>,
11994 offset: usize,
11995 _depth: fidl::encoding::Depth,
11996 ) -> fidl::Result<()> {
11997 encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
11998 fidl::encoding::Encode::<StreamProcessorOnFreeInputPacketRequest, D>::encode(
12000 (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
12001 &self.free_input_packet,
12002 ),),
12003 encoder,
12004 offset,
12005 _depth,
12006 )
12007 }
12008 }
12009 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
12010 fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D> for (T0,)
12011 {
12012 #[inline]
12013 unsafe fn encode(
12014 self,
12015 encoder: &mut fidl::encoding::Encoder<'_, D>,
12016 offset: usize,
12017 depth: fidl::encoding::Depth,
12018 ) -> fidl::Result<()> {
12019 encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
12020 self.0.encode(encoder, offset + 0, depth)?;
12024 Ok(())
12025 }
12026 }
12027
12028 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12029 for StreamProcessorOnFreeInputPacketRequest
12030 {
12031 #[inline(always)]
12032 fn new_empty() -> Self {
12033 Self { free_input_packet: fidl::new_empty!(PacketHeader, D) }
12034 }
12035
12036 #[inline]
12037 unsafe fn decode(
12038 &mut self,
12039 decoder: &mut fidl::encoding::Decoder<'_, D>,
12040 offset: usize,
12041 _depth: fidl::encoding::Depth,
12042 ) -> fidl::Result<()> {
12043 decoder.debug_check_bounds::<Self>(offset);
12044 fidl::decode!(
12046 PacketHeader,
12047 D,
12048 &mut self.free_input_packet,
12049 decoder,
12050 offset + 0,
12051 _depth
12052 )?;
12053 Ok(())
12054 }
12055 }
12056
12057 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnInputConstraintsRequest {
12058 type Borrowed<'a> = &'a Self;
12059 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12060 value
12061 }
12062 }
12063
12064 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnInputConstraintsRequest {
12065 type Owned = Self;
12066
12067 #[inline(always)]
12068 fn inline_align(_context: fidl::encoding::Context) -> usize {
12069 8
12070 }
12071
12072 #[inline(always)]
12073 fn inline_size(_context: fidl::encoding::Context) -> usize {
12074 16
12075 }
12076 }
12077
12078 unsafe impl<D: fidl::encoding::ResourceDialect>
12079 fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D>
12080 for &StreamProcessorOnInputConstraintsRequest
12081 {
12082 #[inline]
12083 unsafe fn encode(
12084 self,
12085 encoder: &mut fidl::encoding::Encoder<'_, D>,
12086 offset: usize,
12087 _depth: fidl::encoding::Depth,
12088 ) -> fidl::Result<()> {
12089 encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12090 fidl::encoding::Encode::<StreamProcessorOnInputConstraintsRequest, D>::encode(
12092 (<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12093 &self.input_constraints,
12094 ),),
12095 encoder,
12096 offset,
12097 _depth,
12098 )
12099 }
12100 }
12101 unsafe impl<
12102 D: fidl::encoding::ResourceDialect,
12103 T0: fidl::encoding::Encode<StreamBufferConstraints, D>,
12104 > fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D> for (T0,)
12105 {
12106 #[inline]
12107 unsafe fn encode(
12108 self,
12109 encoder: &mut fidl::encoding::Encoder<'_, D>,
12110 offset: usize,
12111 depth: fidl::encoding::Depth,
12112 ) -> fidl::Result<()> {
12113 encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12114 self.0.encode(encoder, offset + 0, depth)?;
12118 Ok(())
12119 }
12120 }
12121
12122 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12123 for StreamProcessorOnInputConstraintsRequest
12124 {
12125 #[inline(always)]
12126 fn new_empty() -> Self {
12127 Self { input_constraints: fidl::new_empty!(StreamBufferConstraints, D) }
12128 }
12129
12130 #[inline]
12131 unsafe fn decode(
12132 &mut self,
12133 decoder: &mut fidl::encoding::Decoder<'_, D>,
12134 offset: usize,
12135 _depth: fidl::encoding::Depth,
12136 ) -> fidl::Result<()> {
12137 decoder.debug_check_bounds::<Self>(offset);
12138 fidl::decode!(
12140 StreamBufferConstraints,
12141 D,
12142 &mut self.input_constraints,
12143 decoder,
12144 offset + 0,
12145 _depth
12146 )?;
12147 Ok(())
12148 }
12149 }
12150
12151 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputConstraintsRequest {
12152 type Borrowed<'a> = &'a Self;
12153 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12154 value
12155 }
12156 }
12157
12158 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputConstraintsRequest {
12159 type Owned = Self;
12160
12161 #[inline(always)]
12162 fn inline_align(_context: fidl::encoding::Context) -> usize {
12163 8
12164 }
12165
12166 #[inline(always)]
12167 fn inline_size(_context: fidl::encoding::Context) -> usize {
12168 16
12169 }
12170 }
12171
12172 unsafe impl<D: fidl::encoding::ResourceDialect>
12173 fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D>
12174 for &StreamProcessorOnOutputConstraintsRequest
12175 {
12176 #[inline]
12177 unsafe fn encode(
12178 self,
12179 encoder: &mut fidl::encoding::Encoder<'_, D>,
12180 offset: usize,
12181 _depth: fidl::encoding::Depth,
12182 ) -> fidl::Result<()> {
12183 encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12184 fidl::encoding::Encode::<StreamProcessorOnOutputConstraintsRequest, D>::encode(
12186 (<StreamOutputConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12187 &self.output_config,
12188 ),),
12189 encoder,
12190 offset,
12191 _depth,
12192 )
12193 }
12194 }
12195 unsafe impl<
12196 D: fidl::encoding::ResourceDialect,
12197 T0: fidl::encoding::Encode<StreamOutputConstraints, D>,
12198 > fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D> for (T0,)
12199 {
12200 #[inline]
12201 unsafe fn encode(
12202 self,
12203 encoder: &mut fidl::encoding::Encoder<'_, D>,
12204 offset: usize,
12205 depth: fidl::encoding::Depth,
12206 ) -> fidl::Result<()> {
12207 encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12208 self.0.encode(encoder, offset + 0, depth)?;
12212 Ok(())
12213 }
12214 }
12215
12216 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12217 for StreamProcessorOnOutputConstraintsRequest
12218 {
12219 #[inline(always)]
12220 fn new_empty() -> Self {
12221 Self { output_config: fidl::new_empty!(StreamOutputConstraints, D) }
12222 }
12223
12224 #[inline]
12225 unsafe fn decode(
12226 &mut self,
12227 decoder: &mut fidl::encoding::Decoder<'_, D>,
12228 offset: usize,
12229 _depth: fidl::encoding::Depth,
12230 ) -> fidl::Result<()> {
12231 decoder.debug_check_bounds::<Self>(offset);
12232 fidl::decode!(
12234 StreamOutputConstraints,
12235 D,
12236 &mut self.output_config,
12237 decoder,
12238 offset + 0,
12239 _depth
12240 )?;
12241 Ok(())
12242 }
12243 }
12244
12245 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12246 type Borrowed<'a> = &'a Self;
12247 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12248 value
12249 }
12250 }
12251
12252 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12253 type Owned = Self;
12254
12255 #[inline(always)]
12256 fn inline_align(_context: fidl::encoding::Context) -> usize {
12257 8
12258 }
12259
12260 #[inline(always)]
12261 fn inline_size(_context: fidl::encoding::Context) -> usize {
12262 16
12263 }
12264 }
12265
12266 unsafe impl<D: fidl::encoding::ResourceDialect>
12267 fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D>
12268 for &StreamProcessorOnOutputEndOfStreamRequest
12269 {
12270 #[inline]
12271 unsafe fn encode(
12272 self,
12273 encoder: &mut fidl::encoding::Encoder<'_, D>,
12274 offset: usize,
12275 _depth: fidl::encoding::Depth,
12276 ) -> fidl::Result<()> {
12277 encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12278 fidl::encoding::Encode::<StreamProcessorOnOutputEndOfStreamRequest, D>::encode(
12280 (
12281 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12282 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12283 ),
12284 encoder,
12285 offset,
12286 _depth,
12287 )
12288 }
12289 }
12290 unsafe impl<
12291 D: fidl::encoding::ResourceDialect,
12292 T0: fidl::encoding::Encode<u64, D>,
12293 T1: fidl::encoding::Encode<bool, D>,
12294 > fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D> for (T0, T1)
12295 {
12296 #[inline]
12297 unsafe fn encode(
12298 self,
12299 encoder: &mut fidl::encoding::Encoder<'_, D>,
12300 offset: usize,
12301 depth: fidl::encoding::Depth,
12302 ) -> fidl::Result<()> {
12303 encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12304 unsafe {
12307 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12308 (ptr as *mut u64).write_unaligned(0);
12309 }
12310 self.0.encode(encoder, offset + 0, depth)?;
12312 self.1.encode(encoder, offset + 8, depth)?;
12313 Ok(())
12314 }
12315 }
12316
12317 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12318 for StreamProcessorOnOutputEndOfStreamRequest
12319 {
12320 #[inline(always)]
12321 fn new_empty() -> Self {
12322 Self {
12323 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12324 error_detected_before: fidl::new_empty!(bool, D),
12325 }
12326 }
12327
12328 #[inline]
12329 unsafe fn decode(
12330 &mut self,
12331 decoder: &mut fidl::encoding::Decoder<'_, D>,
12332 offset: usize,
12333 _depth: fidl::encoding::Depth,
12334 ) -> fidl::Result<()> {
12335 decoder.debug_check_bounds::<Self>(offset);
12336 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12338 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12339 let mask = 0xffffffffffffff00u64;
12340 let maskedval = padval & mask;
12341 if maskedval != 0 {
12342 return Err(fidl::Error::NonZeroPadding {
12343 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12344 });
12345 }
12346 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12347 fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 8, _depth)?;
12348 Ok(())
12349 }
12350 }
12351
12352 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputFormatRequest {
12353 type Borrowed<'a> = &'a Self;
12354 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12355 value
12356 }
12357 }
12358
12359 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputFormatRequest {
12360 type Owned = Self;
12361
12362 #[inline(always)]
12363 fn inline_align(_context: fidl::encoding::Context) -> usize {
12364 8
12365 }
12366
12367 #[inline(always)]
12368 fn inline_size(_context: fidl::encoding::Context) -> usize {
12369 16
12370 }
12371 }
12372
12373 unsafe impl<D: fidl::encoding::ResourceDialect>
12374 fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D>
12375 for &StreamProcessorOnOutputFormatRequest
12376 {
12377 #[inline]
12378 unsafe fn encode(
12379 self,
12380 encoder: &mut fidl::encoding::Encoder<'_, D>,
12381 offset: usize,
12382 _depth: fidl::encoding::Depth,
12383 ) -> fidl::Result<()> {
12384 encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12385 fidl::encoding::Encode::<StreamProcessorOnOutputFormatRequest, D>::encode(
12387 (<StreamOutputFormat as fidl::encoding::ValueTypeMarker>::borrow(
12388 &self.output_format,
12389 ),),
12390 encoder,
12391 offset,
12392 _depth,
12393 )
12394 }
12395 }
12396 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamOutputFormat, D>>
12397 fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D> for (T0,)
12398 {
12399 #[inline]
12400 unsafe fn encode(
12401 self,
12402 encoder: &mut fidl::encoding::Encoder<'_, D>,
12403 offset: usize,
12404 depth: fidl::encoding::Depth,
12405 ) -> fidl::Result<()> {
12406 encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12407 self.0.encode(encoder, offset + 0, depth)?;
12411 Ok(())
12412 }
12413 }
12414
12415 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12416 for StreamProcessorOnOutputFormatRequest
12417 {
12418 #[inline(always)]
12419 fn new_empty() -> Self {
12420 Self { output_format: fidl::new_empty!(StreamOutputFormat, D) }
12421 }
12422
12423 #[inline]
12424 unsafe fn decode(
12425 &mut self,
12426 decoder: &mut fidl::encoding::Decoder<'_, D>,
12427 offset: usize,
12428 _depth: fidl::encoding::Depth,
12429 ) -> fidl::Result<()> {
12430 decoder.debug_check_bounds::<Self>(offset);
12431 fidl::decode!(
12433 StreamOutputFormat,
12434 D,
12435 &mut self.output_format,
12436 decoder,
12437 offset + 0,
12438 _depth
12439 )?;
12440 Ok(())
12441 }
12442 }
12443
12444 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputPacketRequest {
12445 type Borrowed<'a> = &'a Self;
12446 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12447 value
12448 }
12449 }
12450
12451 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputPacketRequest {
12452 type Owned = Self;
12453
12454 #[inline(always)]
12455 fn inline_align(_context: fidl::encoding::Context) -> usize {
12456 8
12457 }
12458
12459 #[inline(always)]
12460 fn inline_size(_context: fidl::encoding::Context) -> usize {
12461 24
12462 }
12463 }
12464
12465 unsafe impl<D: fidl::encoding::ResourceDialect>
12466 fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D>
12467 for &StreamProcessorOnOutputPacketRequest
12468 {
12469 #[inline]
12470 unsafe fn encode(
12471 self,
12472 encoder: &mut fidl::encoding::Encoder<'_, D>,
12473 offset: usize,
12474 _depth: fidl::encoding::Depth,
12475 ) -> fidl::Result<()> {
12476 encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12477 fidl::encoding::Encode::<StreamProcessorOnOutputPacketRequest, D>::encode(
12479 (
12480 <Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.output_packet),
12481 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12482 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_during),
12483 ),
12484 encoder,
12485 offset,
12486 _depth,
12487 )
12488 }
12489 }
12490 unsafe impl<
12491 D: fidl::encoding::ResourceDialect,
12492 T0: fidl::encoding::Encode<Packet, D>,
12493 T1: fidl::encoding::Encode<bool, D>,
12494 T2: fidl::encoding::Encode<bool, D>,
12495 > fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D> for (T0, T1, T2)
12496 {
12497 #[inline]
12498 unsafe fn encode(
12499 self,
12500 encoder: &mut fidl::encoding::Encoder<'_, D>,
12501 offset: usize,
12502 depth: fidl::encoding::Depth,
12503 ) -> fidl::Result<()> {
12504 encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12505 unsafe {
12508 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
12509 (ptr as *mut u64).write_unaligned(0);
12510 }
12511 self.0.encode(encoder, offset + 0, depth)?;
12513 self.1.encode(encoder, offset + 16, depth)?;
12514 self.2.encode(encoder, offset + 17, depth)?;
12515 Ok(())
12516 }
12517 }
12518
12519 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12520 for StreamProcessorOnOutputPacketRequest
12521 {
12522 #[inline(always)]
12523 fn new_empty() -> Self {
12524 Self {
12525 output_packet: fidl::new_empty!(Packet, D),
12526 error_detected_before: fidl::new_empty!(bool, D),
12527 error_detected_during: fidl::new_empty!(bool, D),
12528 }
12529 }
12530
12531 #[inline]
12532 unsafe fn decode(
12533 &mut self,
12534 decoder: &mut fidl::encoding::Decoder<'_, D>,
12535 offset: usize,
12536 _depth: fidl::encoding::Depth,
12537 ) -> fidl::Result<()> {
12538 decoder.debug_check_bounds::<Self>(offset);
12539 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
12541 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12542 let mask = 0xffffffffffff0000u64;
12543 let maskedval = padval & mask;
12544 if maskedval != 0 {
12545 return Err(fidl::Error::NonZeroPadding {
12546 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
12547 });
12548 }
12549 fidl::decode!(Packet, D, &mut self.output_packet, decoder, offset + 0, _depth)?;
12550 fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 16, _depth)?;
12551 fidl::decode!(bool, D, &mut self.error_detected_during, decoder, offset + 17, _depth)?;
12552 Ok(())
12553 }
12554 }
12555
12556 impl fidl::encoding::ValueTypeMarker for StreamProcessorOnStreamFailedRequest {
12557 type Borrowed<'a> = &'a Self;
12558 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12559 value
12560 }
12561 }
12562
12563 unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnStreamFailedRequest {
12564 type Owned = Self;
12565
12566 #[inline(always)]
12567 fn inline_align(_context: fidl::encoding::Context) -> usize {
12568 8
12569 }
12570
12571 #[inline(always)]
12572 fn inline_size(_context: fidl::encoding::Context) -> usize {
12573 16
12574 }
12575 }
12576
12577 unsafe impl<D: fidl::encoding::ResourceDialect>
12578 fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D>
12579 for &StreamProcessorOnStreamFailedRequest
12580 {
12581 #[inline]
12582 unsafe fn encode(
12583 self,
12584 encoder: &mut fidl::encoding::Encoder<'_, D>,
12585 offset: usize,
12586 _depth: fidl::encoding::Depth,
12587 ) -> fidl::Result<()> {
12588 encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12589 fidl::encoding::Encode::<StreamProcessorOnStreamFailedRequest, D>::encode(
12591 (
12592 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12593 <StreamError as fidl::encoding::ValueTypeMarker>::borrow(&self.error),
12594 ),
12595 encoder,
12596 offset,
12597 _depth,
12598 )
12599 }
12600 }
12601 unsafe impl<
12602 D: fidl::encoding::ResourceDialect,
12603 T0: fidl::encoding::Encode<u64, D>,
12604 T1: fidl::encoding::Encode<StreamError, D>,
12605 > fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D> for (T0, T1)
12606 {
12607 #[inline]
12608 unsafe fn encode(
12609 self,
12610 encoder: &mut fidl::encoding::Encoder<'_, D>,
12611 offset: usize,
12612 depth: fidl::encoding::Depth,
12613 ) -> fidl::Result<()> {
12614 encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12615 unsafe {
12618 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12619 (ptr as *mut u64).write_unaligned(0);
12620 }
12621 self.0.encode(encoder, offset + 0, depth)?;
12623 self.1.encode(encoder, offset + 8, depth)?;
12624 Ok(())
12625 }
12626 }
12627
12628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12629 for StreamProcessorOnStreamFailedRequest
12630 {
12631 #[inline(always)]
12632 fn new_empty() -> Self {
12633 Self {
12634 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12635 error: fidl::new_empty!(StreamError, D),
12636 }
12637 }
12638
12639 #[inline]
12640 unsafe fn decode(
12641 &mut self,
12642 decoder: &mut fidl::encoding::Decoder<'_, D>,
12643 offset: usize,
12644 _depth: fidl::encoding::Depth,
12645 ) -> fidl::Result<()> {
12646 decoder.debug_check_bounds::<Self>(offset);
12647 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12649 let padval = unsafe { (ptr as *const u64).read_unaligned() };
12650 let mask = 0xffffffff00000000u64;
12651 let maskedval = padval & mask;
12652 if maskedval != 0 {
12653 return Err(fidl::Error::NonZeroPadding {
12654 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12655 });
12656 }
12657 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12658 fidl::decode!(StreamError, D, &mut self.error, decoder, offset + 8, _depth)?;
12659 Ok(())
12660 }
12661 }
12662
12663 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12664 type Borrowed<'a> = &'a Self;
12665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12666 value
12667 }
12668 }
12669
12670 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12671 type Owned = Self;
12672
12673 #[inline(always)]
12674 fn inline_align(_context: fidl::encoding::Context) -> usize {
12675 8
12676 }
12677
12678 #[inline(always)]
12679 fn inline_size(_context: fidl::encoding::Context) -> usize {
12680 8
12681 }
12682 #[inline(always)]
12683 fn encode_is_copy() -> bool {
12684 true
12685 }
12686
12687 #[inline(always)]
12688 fn decode_is_copy() -> bool {
12689 true
12690 }
12691 }
12692
12693 unsafe impl<D: fidl::encoding::ResourceDialect>
12694 fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D>
12695 for &StreamProcessorQueueInputEndOfStreamRequest
12696 {
12697 #[inline]
12698 unsafe fn encode(
12699 self,
12700 encoder: &mut fidl::encoding::Encoder<'_, D>,
12701 offset: usize,
12702 _depth: fidl::encoding::Depth,
12703 ) -> fidl::Result<()> {
12704 encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12705 unsafe {
12706 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12708 (buf_ptr as *mut StreamProcessorQueueInputEndOfStreamRequest).write_unaligned(
12709 (self as *const StreamProcessorQueueInputEndOfStreamRequest).read(),
12710 );
12711 }
12714 Ok(())
12715 }
12716 }
12717 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12718 fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D> for (T0,)
12719 {
12720 #[inline]
12721 unsafe fn encode(
12722 self,
12723 encoder: &mut fidl::encoding::Encoder<'_, D>,
12724 offset: usize,
12725 depth: fidl::encoding::Depth,
12726 ) -> fidl::Result<()> {
12727 encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12728 self.0.encode(encoder, offset + 0, depth)?;
12732 Ok(())
12733 }
12734 }
12735
12736 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12737 for StreamProcessorQueueInputEndOfStreamRequest
12738 {
12739 #[inline(always)]
12740 fn new_empty() -> Self {
12741 Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
12742 }
12743
12744 #[inline]
12745 unsafe fn decode(
12746 &mut self,
12747 decoder: &mut fidl::encoding::Decoder<'_, D>,
12748 offset: usize,
12749 _depth: fidl::encoding::Depth,
12750 ) -> fidl::Result<()> {
12751 decoder.debug_check_bounds::<Self>(offset);
12752 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12753 unsafe {
12756 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12757 }
12758 Ok(())
12759 }
12760 }
12761
12762 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12763 type Borrowed<'a> = &'a Self;
12764 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12765 value
12766 }
12767 }
12768
12769 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12770 type Owned = Self;
12771
12772 #[inline(always)]
12773 fn inline_align(_context: fidl::encoding::Context) -> usize {
12774 8
12775 }
12776
12777 #[inline(always)]
12778 fn inline_size(_context: fidl::encoding::Context) -> usize {
12779 24
12780 }
12781 }
12782
12783 unsafe impl<D: fidl::encoding::ResourceDialect>
12784 fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D>
12785 for &StreamProcessorQueueInputFormatDetailsRequest
12786 {
12787 #[inline]
12788 unsafe fn encode(
12789 self,
12790 encoder: &mut fidl::encoding::Encoder<'_, D>,
12791 offset: usize,
12792 _depth: fidl::encoding::Depth,
12793 ) -> fidl::Result<()> {
12794 encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
12795 fidl::encoding::Encode::<StreamProcessorQueueInputFormatDetailsRequest, D>::encode(
12797 (
12798 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12799 <FormatDetails as fidl::encoding::ValueTypeMarker>::borrow(
12800 &self.format_details,
12801 ),
12802 ),
12803 encoder,
12804 offset,
12805 _depth,
12806 )
12807 }
12808 }
12809 unsafe impl<
12810 D: fidl::encoding::ResourceDialect,
12811 T0: fidl::encoding::Encode<u64, D>,
12812 T1: fidl::encoding::Encode<FormatDetails, D>,
12813 > fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D> for (T0, T1)
12814 {
12815 #[inline]
12816 unsafe fn encode(
12817 self,
12818 encoder: &mut fidl::encoding::Encoder<'_, D>,
12819 offset: usize,
12820 depth: fidl::encoding::Depth,
12821 ) -> fidl::Result<()> {
12822 encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
12823 self.0.encode(encoder, offset + 0, depth)?;
12827 self.1.encode(encoder, offset + 8, depth)?;
12828 Ok(())
12829 }
12830 }
12831
12832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12833 for StreamProcessorQueueInputFormatDetailsRequest
12834 {
12835 #[inline(always)]
12836 fn new_empty() -> Self {
12837 Self {
12838 stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12839 format_details: fidl::new_empty!(FormatDetails, D),
12840 }
12841 }
12842
12843 #[inline]
12844 unsafe fn decode(
12845 &mut self,
12846 decoder: &mut fidl::encoding::Decoder<'_, D>,
12847 offset: usize,
12848 _depth: fidl::encoding::Depth,
12849 ) -> fidl::Result<()> {
12850 decoder.debug_check_bounds::<Self>(offset);
12851 fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12853 fidl::decode!(FormatDetails, D, &mut self.format_details, decoder, offset + 8, _depth)?;
12854 Ok(())
12855 }
12856 }
12857
12858 impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputPacketRequest {
12859 type Borrowed<'a> = &'a Self;
12860 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12861 value
12862 }
12863 }
12864
12865 unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputPacketRequest {
12866 type Owned = Self;
12867
12868 #[inline(always)]
12869 fn inline_align(_context: fidl::encoding::Context) -> usize {
12870 8
12871 }
12872
12873 #[inline(always)]
12874 fn inline_size(_context: fidl::encoding::Context) -> usize {
12875 16
12876 }
12877 }
12878
12879 unsafe impl<D: fidl::encoding::ResourceDialect>
12880 fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D>
12881 for &StreamProcessorQueueInputPacketRequest
12882 {
12883 #[inline]
12884 unsafe fn encode(
12885 self,
12886 encoder: &mut fidl::encoding::Encoder<'_, D>,
12887 offset: usize,
12888 _depth: fidl::encoding::Depth,
12889 ) -> fidl::Result<()> {
12890 encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
12891 fidl::encoding::Encode::<StreamProcessorQueueInputPacketRequest, D>::encode(
12893 (<Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.packet),),
12894 encoder,
12895 offset,
12896 _depth,
12897 )
12898 }
12899 }
12900 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Packet, D>>
12901 fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D> for (T0,)
12902 {
12903 #[inline]
12904 unsafe fn encode(
12905 self,
12906 encoder: &mut fidl::encoding::Encoder<'_, D>,
12907 offset: usize,
12908 depth: fidl::encoding::Depth,
12909 ) -> fidl::Result<()> {
12910 encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
12911 self.0.encode(encoder, offset + 0, depth)?;
12915 Ok(())
12916 }
12917 }
12918
12919 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12920 for StreamProcessorQueueInputPacketRequest
12921 {
12922 #[inline(always)]
12923 fn new_empty() -> Self {
12924 Self { packet: fidl::new_empty!(Packet, D) }
12925 }
12926
12927 #[inline]
12928 unsafe fn decode(
12929 &mut self,
12930 decoder: &mut fidl::encoding::Decoder<'_, D>,
12931 offset: usize,
12932 _depth: fidl::encoding::Depth,
12933 ) -> fidl::Result<()> {
12934 decoder.debug_check_bounds::<Self>(offset);
12935 fidl::decode!(Packet, D, &mut self.packet, decoder, offset + 0, _depth)?;
12937 Ok(())
12938 }
12939 }
12940
12941 impl fidl::encoding::ValueTypeMarker for StreamProcessorRecycleOutputPacketRequest {
12942 type Borrowed<'a> = &'a Self;
12943 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12944 value
12945 }
12946 }
12947
12948 unsafe impl fidl::encoding::TypeMarker for StreamProcessorRecycleOutputPacketRequest {
12949 type Owned = Self;
12950
12951 #[inline(always)]
12952 fn inline_align(_context: fidl::encoding::Context) -> usize {
12953 8
12954 }
12955
12956 #[inline(always)]
12957 fn inline_size(_context: fidl::encoding::Context) -> usize {
12958 16
12959 }
12960 }
12961
12962 unsafe impl<D: fidl::encoding::ResourceDialect>
12963 fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D>
12964 for &StreamProcessorRecycleOutputPacketRequest
12965 {
12966 #[inline]
12967 unsafe fn encode(
12968 self,
12969 encoder: &mut fidl::encoding::Encoder<'_, D>,
12970 offset: usize,
12971 _depth: fidl::encoding::Depth,
12972 ) -> fidl::Result<()> {
12973 encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
12974 fidl::encoding::Encode::<StreamProcessorRecycleOutputPacketRequest, D>::encode(
12976 (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
12977 &self.available_output_packet,
12978 ),),
12979 encoder,
12980 offset,
12981 _depth,
12982 )
12983 }
12984 }
12985 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
12986 fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D> for (T0,)
12987 {
12988 #[inline]
12989 unsafe fn encode(
12990 self,
12991 encoder: &mut fidl::encoding::Encoder<'_, D>,
12992 offset: usize,
12993 depth: fidl::encoding::Depth,
12994 ) -> fidl::Result<()> {
12995 encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
12996 self.0.encode(encoder, offset + 0, depth)?;
13000 Ok(())
13001 }
13002 }
13003
13004 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13005 for StreamProcessorRecycleOutputPacketRequest
13006 {
13007 #[inline(always)]
13008 fn new_empty() -> Self {
13009 Self { available_output_packet: fidl::new_empty!(PacketHeader, D) }
13010 }
13011
13012 #[inline]
13013 unsafe fn decode(
13014 &mut self,
13015 decoder: &mut fidl::encoding::Decoder<'_, D>,
13016 offset: usize,
13017 _depth: fidl::encoding::Depth,
13018 ) -> fidl::Result<()> {
13019 decoder.debug_check_bounds::<Self>(offset);
13020 fidl::decode!(
13022 PacketHeader,
13023 D,
13024 &mut self.available_output_packet,
13025 decoder,
13026 offset + 0,
13027 _depth
13028 )?;
13029 Ok(())
13030 }
13031 }
13032
13033 impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketNoReplyRequest {
13034 type Borrowed<'a> = &'a Self;
13035 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13036 value
13037 }
13038 }
13039
13040 unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketNoReplyRequest {
13041 type Owned = Self;
13042
13043 #[inline(always)]
13044 fn inline_align(_context: fidl::encoding::Context) -> usize {
13045 8
13046 }
13047
13048 #[inline(always)]
13049 fn inline_size(_context: fidl::encoding::Context) -> usize {
13050 56
13051 }
13052 }
13053
13054 unsafe impl<D: fidl::encoding::ResourceDialect>
13055 fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D>
13056 for &StreamSinkSendPacketNoReplyRequest
13057 {
13058 #[inline]
13059 unsafe fn encode(
13060 self,
13061 encoder: &mut fidl::encoding::Encoder<'_, D>,
13062 offset: usize,
13063 _depth: fidl::encoding::Depth,
13064 ) -> fidl::Result<()> {
13065 encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13066 unsafe {
13067 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13069 (buf_ptr as *mut StreamSinkSendPacketNoReplyRequest)
13070 .write_unaligned((self as *const StreamSinkSendPacketNoReplyRequest).read());
13071 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13074 let padding_mask = 0xffffffff00000000u64;
13075 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13076 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13077 let padding_mask = 0xffffffff00000000u64;
13078 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13079 }
13080 Ok(())
13081 }
13082 }
13083 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13084 fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D> for (T0,)
13085 {
13086 #[inline]
13087 unsafe fn encode(
13088 self,
13089 encoder: &mut fidl::encoding::Encoder<'_, D>,
13090 offset: usize,
13091 depth: fidl::encoding::Depth,
13092 ) -> fidl::Result<()> {
13093 encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13094 self.0.encode(encoder, offset + 0, depth)?;
13098 Ok(())
13099 }
13100 }
13101
13102 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13103 for StreamSinkSendPacketNoReplyRequest
13104 {
13105 #[inline(always)]
13106 fn new_empty() -> Self {
13107 Self { packet: fidl::new_empty!(StreamPacket, D) }
13108 }
13109
13110 #[inline]
13111 unsafe fn decode(
13112 &mut self,
13113 decoder: &mut fidl::encoding::Decoder<'_, D>,
13114 offset: usize,
13115 _depth: fidl::encoding::Depth,
13116 ) -> fidl::Result<()> {
13117 decoder.debug_check_bounds::<Self>(offset);
13118 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13119 let ptr = unsafe { buf_ptr.offset(8) };
13121 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13122 let mask = 0xffffffff00000000u64;
13123 let maskedval = padval & mask;
13124 if maskedval != 0 {
13125 return Err(fidl::Error::NonZeroPadding {
13126 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13127 });
13128 }
13129 let ptr = unsafe { buf_ptr.offset(32) };
13130 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13131 let mask = 0xffffffff00000000u64;
13132 let maskedval = padval & mask;
13133 if maskedval != 0 {
13134 return Err(fidl::Error::NonZeroPadding {
13135 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13136 });
13137 }
13138 unsafe {
13140 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13141 }
13142 Ok(())
13143 }
13144 }
13145
13146 impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketRequest {
13147 type Borrowed<'a> = &'a Self;
13148 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13149 value
13150 }
13151 }
13152
13153 unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketRequest {
13154 type Owned = Self;
13155
13156 #[inline(always)]
13157 fn inline_align(_context: fidl::encoding::Context) -> usize {
13158 8
13159 }
13160
13161 #[inline(always)]
13162 fn inline_size(_context: fidl::encoding::Context) -> usize {
13163 56
13164 }
13165 }
13166
13167 unsafe impl<D: fidl::encoding::ResourceDialect>
13168 fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for &StreamSinkSendPacketRequest
13169 {
13170 #[inline]
13171 unsafe fn encode(
13172 self,
13173 encoder: &mut fidl::encoding::Encoder<'_, D>,
13174 offset: usize,
13175 _depth: fidl::encoding::Depth,
13176 ) -> fidl::Result<()> {
13177 encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13178 unsafe {
13179 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13181 (buf_ptr as *mut StreamSinkSendPacketRequest)
13182 .write_unaligned((self as *const StreamSinkSendPacketRequest).read());
13183 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13186 let padding_mask = 0xffffffff00000000u64;
13187 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13188 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13189 let padding_mask = 0xffffffff00000000u64;
13190 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13191 }
13192 Ok(())
13193 }
13194 }
13195 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13196 fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for (T0,)
13197 {
13198 #[inline]
13199 unsafe fn encode(
13200 self,
13201 encoder: &mut fidl::encoding::Encoder<'_, D>,
13202 offset: usize,
13203 depth: fidl::encoding::Depth,
13204 ) -> fidl::Result<()> {
13205 encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13206 self.0.encode(encoder, offset + 0, depth)?;
13210 Ok(())
13211 }
13212 }
13213
13214 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13215 for StreamSinkSendPacketRequest
13216 {
13217 #[inline(always)]
13218 fn new_empty() -> Self {
13219 Self { packet: fidl::new_empty!(StreamPacket, D) }
13220 }
13221
13222 #[inline]
13223 unsafe fn decode(
13224 &mut self,
13225 decoder: &mut fidl::encoding::Decoder<'_, D>,
13226 offset: usize,
13227 _depth: fidl::encoding::Depth,
13228 ) -> fidl::Result<()> {
13229 decoder.debug_check_bounds::<Self>(offset);
13230 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13231 let ptr = unsafe { buf_ptr.offset(8) };
13233 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13234 let mask = 0xffffffff00000000u64;
13235 let maskedval = padval & mask;
13236 if maskedval != 0 {
13237 return Err(fidl::Error::NonZeroPadding {
13238 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13239 });
13240 }
13241 let ptr = unsafe { buf_ptr.offset(32) };
13242 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13243 let mask = 0xffffffff00000000u64;
13244 let maskedval = padval & mask;
13245 if maskedval != 0 {
13246 return Err(fidl::Error::NonZeroPadding {
13247 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13248 });
13249 }
13250 unsafe {
13252 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13253 }
13254 Ok(())
13255 }
13256 }
13257
13258 impl fidl::encoding::ValueTypeMarker for StreamSourceOnPacketProducedRequest {
13259 type Borrowed<'a> = &'a Self;
13260 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13261 value
13262 }
13263 }
13264
13265 unsafe impl fidl::encoding::TypeMarker for StreamSourceOnPacketProducedRequest {
13266 type Owned = Self;
13267
13268 #[inline(always)]
13269 fn inline_align(_context: fidl::encoding::Context) -> usize {
13270 8
13271 }
13272
13273 #[inline(always)]
13274 fn inline_size(_context: fidl::encoding::Context) -> usize {
13275 56
13276 }
13277 }
13278
13279 unsafe impl<D: fidl::encoding::ResourceDialect>
13280 fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D>
13281 for &StreamSourceOnPacketProducedRequest
13282 {
13283 #[inline]
13284 unsafe fn encode(
13285 self,
13286 encoder: &mut fidl::encoding::Encoder<'_, D>,
13287 offset: usize,
13288 _depth: fidl::encoding::Depth,
13289 ) -> fidl::Result<()> {
13290 encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13291 unsafe {
13292 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13294 (buf_ptr as *mut StreamSourceOnPacketProducedRequest)
13295 .write_unaligned((self as *const StreamSourceOnPacketProducedRequest).read());
13296 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13299 let padding_mask = 0xffffffff00000000u64;
13300 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13301 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13302 let padding_mask = 0xffffffff00000000u64;
13303 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13304 }
13305 Ok(())
13306 }
13307 }
13308 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13309 fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D> for (T0,)
13310 {
13311 #[inline]
13312 unsafe fn encode(
13313 self,
13314 encoder: &mut fidl::encoding::Encoder<'_, D>,
13315 offset: usize,
13316 depth: fidl::encoding::Depth,
13317 ) -> fidl::Result<()> {
13318 encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13319 self.0.encode(encoder, offset + 0, depth)?;
13323 Ok(())
13324 }
13325 }
13326
13327 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13328 for StreamSourceOnPacketProducedRequest
13329 {
13330 #[inline(always)]
13331 fn new_empty() -> Self {
13332 Self { packet: fidl::new_empty!(StreamPacket, D) }
13333 }
13334
13335 #[inline]
13336 unsafe fn decode(
13337 &mut self,
13338 decoder: &mut fidl::encoding::Decoder<'_, D>,
13339 offset: usize,
13340 _depth: fidl::encoding::Depth,
13341 ) -> fidl::Result<()> {
13342 decoder.debug_check_bounds::<Self>(offset);
13343 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13344 let ptr = unsafe { buf_ptr.offset(8) };
13346 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13347 let mask = 0xffffffff00000000u64;
13348 let maskedval = padval & mask;
13349 if maskedval != 0 {
13350 return Err(fidl::Error::NonZeroPadding {
13351 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13352 });
13353 }
13354 let ptr = unsafe { buf_ptr.offset(32) };
13355 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13356 let mask = 0xffffffff00000000u64;
13357 let maskedval = padval & mask;
13358 if maskedval != 0 {
13359 return Err(fidl::Error::NonZeroPadding {
13360 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13361 });
13362 }
13363 unsafe {
13365 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13366 }
13367 Ok(())
13368 }
13369 }
13370
13371 impl fidl::encoding::ValueTypeMarker for StreamSourceReleasePacketRequest {
13372 type Borrowed<'a> = &'a Self;
13373 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13374 value
13375 }
13376 }
13377
13378 unsafe impl fidl::encoding::TypeMarker for StreamSourceReleasePacketRequest {
13379 type Owned = Self;
13380
13381 #[inline(always)]
13382 fn inline_align(_context: fidl::encoding::Context) -> usize {
13383 8
13384 }
13385
13386 #[inline(always)]
13387 fn inline_size(_context: fidl::encoding::Context) -> usize {
13388 56
13389 }
13390 }
13391
13392 unsafe impl<D: fidl::encoding::ResourceDialect>
13393 fidl::encoding::Encode<StreamSourceReleasePacketRequest, D>
13394 for &StreamSourceReleasePacketRequest
13395 {
13396 #[inline]
13397 unsafe fn encode(
13398 self,
13399 encoder: &mut fidl::encoding::Encoder<'_, D>,
13400 offset: usize,
13401 _depth: fidl::encoding::Depth,
13402 ) -> fidl::Result<()> {
13403 encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13404 unsafe {
13405 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13407 (buf_ptr as *mut StreamSourceReleasePacketRequest)
13408 .write_unaligned((self as *const StreamSourceReleasePacketRequest).read());
13409 let padding_ptr = buf_ptr.offset(8) as *mut u64;
13412 let padding_mask = 0xffffffff00000000u64;
13413 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13414 let padding_ptr = buf_ptr.offset(32) as *mut u64;
13415 let padding_mask = 0xffffffff00000000u64;
13416 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13417 }
13418 Ok(())
13419 }
13420 }
13421 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13422 fidl::encoding::Encode<StreamSourceReleasePacketRequest, D> for (T0,)
13423 {
13424 #[inline]
13425 unsafe fn encode(
13426 self,
13427 encoder: &mut fidl::encoding::Encoder<'_, D>,
13428 offset: usize,
13429 depth: fidl::encoding::Depth,
13430 ) -> fidl::Result<()> {
13431 encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13432 self.0.encode(encoder, offset + 0, depth)?;
13436 Ok(())
13437 }
13438 }
13439
13440 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13441 for StreamSourceReleasePacketRequest
13442 {
13443 #[inline(always)]
13444 fn new_empty() -> Self {
13445 Self { packet: fidl::new_empty!(StreamPacket, D) }
13446 }
13447
13448 #[inline]
13449 unsafe fn decode(
13450 &mut self,
13451 decoder: &mut fidl::encoding::Decoder<'_, D>,
13452 offset: usize,
13453 _depth: fidl::encoding::Depth,
13454 ) -> fidl::Result<()> {
13455 decoder.debug_check_bounds::<Self>(offset);
13456 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13457 let ptr = unsafe { buf_ptr.offset(8) };
13459 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13460 let mask = 0xffffffff00000000u64;
13461 let maskedval = padval & mask;
13462 if maskedval != 0 {
13463 return Err(fidl::Error::NonZeroPadding {
13464 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13465 });
13466 }
13467 let ptr = unsafe { buf_ptr.offset(32) };
13468 let padval = unsafe { (ptr as *const u64).read_unaligned() };
13469 let mask = 0xffffffff00000000u64;
13470 let maskedval = padval & mask;
13471 if maskedval != 0 {
13472 return Err(fidl::Error::NonZeroPadding {
13473 padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13474 });
13475 }
13476 unsafe {
13478 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13479 }
13480 Ok(())
13481 }
13482 }
13483
13484 impl fidl::encoding::ValueTypeMarker for StreamType {
13485 type Borrowed<'a> = &'a Self;
13486 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13487 value
13488 }
13489 }
13490
13491 unsafe impl fidl::encoding::TypeMarker for StreamType {
13492 type Owned = Self;
13493
13494 #[inline(always)]
13495 fn inline_align(_context: fidl::encoding::Context) -> usize {
13496 8
13497 }
13498
13499 #[inline(always)]
13500 fn inline_size(_context: fidl::encoding::Context) -> usize {
13501 48
13502 }
13503 }
13504
13505 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamType, D>
13506 for &StreamType
13507 {
13508 #[inline]
13509 unsafe fn encode(
13510 self,
13511 encoder: &mut fidl::encoding::Encoder<'_, D>,
13512 offset: usize,
13513 _depth: fidl::encoding::Depth,
13514 ) -> fidl::Result<()> {
13515 encoder.debug_check_bounds::<StreamType>(offset);
13516 fidl::encoding::Encode::<StreamType, D>::encode(
13518 (
13519 <MediumSpecificStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.medium_specific),
13520 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding),
13521 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding_parameters),
13522 ),
13523 encoder, offset, _depth
13524 )
13525 }
13526 }
13527 unsafe impl<
13528 D: fidl::encoding::ResourceDialect,
13529 T0: fidl::encoding::Encode<MediumSpecificStreamType, D>,
13530 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
13531 T2: fidl::encoding::Encode<
13532 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13533 D,
13534 >,
13535 > fidl::encoding::Encode<StreamType, D> for (T0, T1, T2)
13536 {
13537 #[inline]
13538 unsafe fn encode(
13539 self,
13540 encoder: &mut fidl::encoding::Encoder<'_, D>,
13541 offset: usize,
13542 depth: fidl::encoding::Depth,
13543 ) -> fidl::Result<()> {
13544 encoder.debug_check_bounds::<StreamType>(offset);
13545 self.0.encode(encoder, offset + 0, depth)?;
13549 self.1.encode(encoder, offset + 16, depth)?;
13550 self.2.encode(encoder, offset + 32, depth)?;
13551 Ok(())
13552 }
13553 }
13554
13555 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamType {
13556 #[inline(always)]
13557 fn new_empty() -> Self {
13558 Self {
13559 medium_specific: fidl::new_empty!(MediumSpecificStreamType, D),
13560 encoding: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
13561 encoding_parameters: fidl::new_empty!(
13562 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13563 D
13564 ),
13565 }
13566 }
13567
13568 #[inline]
13569 unsafe fn decode(
13570 &mut self,
13571 decoder: &mut fidl::encoding::Decoder<'_, D>,
13572 offset: usize,
13573 _depth: fidl::encoding::Depth,
13574 ) -> fidl::Result<()> {
13575 decoder.debug_check_bounds::<Self>(offset);
13576 fidl::decode!(
13578 MediumSpecificStreamType,
13579 D,
13580 &mut self.medium_specific,
13581 decoder,
13582 offset + 0,
13583 _depth
13584 )?;
13585 fidl::decode!(
13586 fidl::encoding::BoundedString<255>,
13587 D,
13588 &mut self.encoding,
13589 decoder,
13590 offset + 16,
13591 _depth
13592 )?;
13593 fidl::decode!(
13594 fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13595 D,
13596 &mut self.encoding_parameters,
13597 decoder,
13598 offset + 32,
13599 _depth
13600 )?;
13601 Ok(())
13602 }
13603 }
13604
13605 impl fidl::encoding::ValueTypeMarker for SubpictureStreamType {
13606 type Borrowed<'a> = &'a Self;
13607 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13608 value
13609 }
13610 }
13611
13612 unsafe impl fidl::encoding::TypeMarker for SubpictureStreamType {
13613 type Owned = Self;
13614
13615 #[inline(always)]
13616 fn inline_align(_context: fidl::encoding::Context) -> usize {
13617 1
13618 }
13619
13620 #[inline(always)]
13621 fn inline_size(_context: fidl::encoding::Context) -> usize {
13622 1
13623 }
13624 }
13625
13626 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubpictureStreamType, D>
13627 for &SubpictureStreamType
13628 {
13629 #[inline]
13630 unsafe fn encode(
13631 self,
13632 encoder: &mut fidl::encoding::Encoder<'_, D>,
13633 offset: usize,
13634 _depth: fidl::encoding::Depth,
13635 ) -> fidl::Result<()> {
13636 encoder.debug_check_bounds::<SubpictureStreamType>(offset);
13637 encoder.write_num(0u8, offset);
13638 Ok(())
13639 }
13640 }
13641
13642 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubpictureStreamType {
13643 #[inline(always)]
13644 fn new_empty() -> Self {
13645 Self
13646 }
13647
13648 #[inline]
13649 unsafe fn decode(
13650 &mut self,
13651 decoder: &mut fidl::encoding::Decoder<'_, D>,
13652 offset: usize,
13653 _depth: fidl::encoding::Depth,
13654 ) -> fidl::Result<()> {
13655 decoder.debug_check_bounds::<Self>(offset);
13656 match decoder.read_num::<u8>(offset) {
13657 0 => Ok(()),
13658 _ => Err(fidl::Error::Invalid),
13659 }
13660 }
13661 }
13662
13663 impl fidl::encoding::ValueTypeMarker for SubsampleEntry {
13664 type Borrowed<'a> = &'a Self;
13665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13666 value
13667 }
13668 }
13669
13670 unsafe impl fidl::encoding::TypeMarker for SubsampleEntry {
13671 type Owned = Self;
13672
13673 #[inline(always)]
13674 fn inline_align(_context: fidl::encoding::Context) -> usize {
13675 4
13676 }
13677
13678 #[inline(always)]
13679 fn inline_size(_context: fidl::encoding::Context) -> usize {
13680 8
13681 }
13682 #[inline(always)]
13683 fn encode_is_copy() -> bool {
13684 true
13685 }
13686
13687 #[inline(always)]
13688 fn decode_is_copy() -> bool {
13689 true
13690 }
13691 }
13692
13693 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubsampleEntry, D>
13694 for &SubsampleEntry
13695 {
13696 #[inline]
13697 unsafe fn encode(
13698 self,
13699 encoder: &mut fidl::encoding::Encoder<'_, D>,
13700 offset: usize,
13701 _depth: fidl::encoding::Depth,
13702 ) -> fidl::Result<()> {
13703 encoder.debug_check_bounds::<SubsampleEntry>(offset);
13704 unsafe {
13705 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13707 (buf_ptr as *mut SubsampleEntry)
13708 .write_unaligned((self as *const SubsampleEntry).read());
13709 }
13712 Ok(())
13713 }
13714 }
13715 unsafe impl<
13716 D: fidl::encoding::ResourceDialect,
13717 T0: fidl::encoding::Encode<u32, D>,
13718 T1: fidl::encoding::Encode<u32, D>,
13719 > fidl::encoding::Encode<SubsampleEntry, D> for (T0, T1)
13720 {
13721 #[inline]
13722 unsafe fn encode(
13723 self,
13724 encoder: &mut fidl::encoding::Encoder<'_, D>,
13725 offset: usize,
13726 depth: fidl::encoding::Depth,
13727 ) -> fidl::Result<()> {
13728 encoder.debug_check_bounds::<SubsampleEntry>(offset);
13729 self.0.encode(encoder, offset + 0, depth)?;
13733 self.1.encode(encoder, offset + 4, depth)?;
13734 Ok(())
13735 }
13736 }
13737
13738 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubsampleEntry {
13739 #[inline(always)]
13740 fn new_empty() -> Self {
13741 Self {
13742 clear_bytes: fidl::new_empty!(u32, D),
13743 encrypted_bytes: fidl::new_empty!(u32, D),
13744 }
13745 }
13746
13747 #[inline]
13748 unsafe fn decode(
13749 &mut self,
13750 decoder: &mut fidl::encoding::Decoder<'_, D>,
13751 offset: usize,
13752 _depth: fidl::encoding::Depth,
13753 ) -> fidl::Result<()> {
13754 decoder.debug_check_bounds::<Self>(offset);
13755 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13756 unsafe {
13759 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
13760 }
13761 Ok(())
13762 }
13763 }
13764
13765 impl fidl::encoding::ValueTypeMarker for TextStreamType {
13766 type Borrowed<'a> = &'a Self;
13767 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13768 value
13769 }
13770 }
13771
13772 unsafe impl fidl::encoding::TypeMarker for TextStreamType {
13773 type Owned = Self;
13774
13775 #[inline(always)]
13776 fn inline_align(_context: fidl::encoding::Context) -> usize {
13777 1
13778 }
13779
13780 #[inline(always)]
13781 fn inline_size(_context: fidl::encoding::Context) -> usize {
13782 1
13783 }
13784 }
13785
13786 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TextStreamType, D>
13787 for &TextStreamType
13788 {
13789 #[inline]
13790 unsafe fn encode(
13791 self,
13792 encoder: &mut fidl::encoding::Encoder<'_, D>,
13793 offset: usize,
13794 _depth: fidl::encoding::Depth,
13795 ) -> fidl::Result<()> {
13796 encoder.debug_check_bounds::<TextStreamType>(offset);
13797 encoder.write_num(0u8, offset);
13798 Ok(())
13799 }
13800 }
13801
13802 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TextStreamType {
13803 #[inline(always)]
13804 fn new_empty() -> Self {
13805 Self
13806 }
13807
13808 #[inline]
13809 unsafe fn decode(
13810 &mut self,
13811 decoder: &mut fidl::encoding::Decoder<'_, D>,
13812 offset: usize,
13813 _depth: fidl::encoding::Depth,
13814 ) -> fidl::Result<()> {
13815 decoder.debug_check_bounds::<Self>(offset);
13816 match decoder.read_num::<u8>(offset) {
13817 0 => Ok(()),
13818 _ => Err(fidl::Error::Invalid),
13819 }
13820 }
13821 }
13822
13823 impl fidl::encoding::ValueTypeMarker for TimelineFunction {
13824 type Borrowed<'a> = &'a Self;
13825 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13826 value
13827 }
13828 }
13829
13830 unsafe impl fidl::encoding::TypeMarker for TimelineFunction {
13831 type Owned = Self;
13832
13833 #[inline(always)]
13834 fn inline_align(_context: fidl::encoding::Context) -> usize {
13835 8
13836 }
13837
13838 #[inline(always)]
13839 fn inline_size(_context: fidl::encoding::Context) -> usize {
13840 24
13841 }
13842 #[inline(always)]
13843 fn encode_is_copy() -> bool {
13844 true
13845 }
13846
13847 #[inline(always)]
13848 fn decode_is_copy() -> bool {
13849 true
13850 }
13851 }
13852
13853 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TimelineFunction, D>
13854 for &TimelineFunction
13855 {
13856 #[inline]
13857 unsafe fn encode(
13858 self,
13859 encoder: &mut fidl::encoding::Encoder<'_, D>,
13860 offset: usize,
13861 _depth: fidl::encoding::Depth,
13862 ) -> fidl::Result<()> {
13863 encoder.debug_check_bounds::<TimelineFunction>(offset);
13864 unsafe {
13865 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13867 (buf_ptr as *mut TimelineFunction)
13868 .write_unaligned((self as *const TimelineFunction).read());
13869 }
13872 Ok(())
13873 }
13874 }
13875 unsafe impl<
13876 D: fidl::encoding::ResourceDialect,
13877 T0: fidl::encoding::Encode<i64, D>,
13878 T1: fidl::encoding::Encode<i64, D>,
13879 T2: fidl::encoding::Encode<u32, D>,
13880 T3: fidl::encoding::Encode<u32, D>,
13881 > fidl::encoding::Encode<TimelineFunction, D> for (T0, T1, T2, T3)
13882 {
13883 #[inline]
13884 unsafe fn encode(
13885 self,
13886 encoder: &mut fidl::encoding::Encoder<'_, D>,
13887 offset: usize,
13888 depth: fidl::encoding::Depth,
13889 ) -> fidl::Result<()> {
13890 encoder.debug_check_bounds::<TimelineFunction>(offset);
13891 self.0.encode(encoder, offset + 0, depth)?;
13895 self.1.encode(encoder, offset + 8, depth)?;
13896 self.2.encode(encoder, offset + 16, depth)?;
13897 self.3.encode(encoder, offset + 20, depth)?;
13898 Ok(())
13899 }
13900 }
13901
13902 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TimelineFunction {
13903 #[inline(always)]
13904 fn new_empty() -> Self {
13905 Self {
13906 subject_time: fidl::new_empty!(i64, D),
13907 reference_time: fidl::new_empty!(i64, D),
13908 subject_delta: fidl::new_empty!(u32, D),
13909 reference_delta: fidl::new_empty!(u32, D),
13910 }
13911 }
13912
13913 #[inline]
13914 unsafe fn decode(
13915 &mut self,
13916 decoder: &mut fidl::encoding::Decoder<'_, D>,
13917 offset: usize,
13918 _depth: fidl::encoding::Depth,
13919 ) -> fidl::Result<()> {
13920 decoder.debug_check_bounds::<Self>(offset);
13921 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13922 unsafe {
13925 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
13926 }
13927 Ok(())
13928 }
13929 }
13930
13931 impl fidl::encoding::ValueTypeMarker for UsageGainListenerOnGainMuteChangedRequest {
13932 type Borrowed<'a> = &'a Self;
13933 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13934 value
13935 }
13936 }
13937
13938 unsafe impl fidl::encoding::TypeMarker for UsageGainListenerOnGainMuteChangedRequest {
13939 type Owned = Self;
13940
13941 #[inline(always)]
13942 fn inline_align(_context: fidl::encoding::Context) -> usize {
13943 4
13944 }
13945
13946 #[inline(always)]
13947 fn inline_size(_context: fidl::encoding::Context) -> usize {
13948 8
13949 }
13950 }
13951
13952 unsafe impl<D: fidl::encoding::ResourceDialect>
13953 fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D>
13954 for &UsageGainListenerOnGainMuteChangedRequest
13955 {
13956 #[inline]
13957 unsafe fn encode(
13958 self,
13959 encoder: &mut fidl::encoding::Encoder<'_, D>,
13960 offset: usize,
13961 _depth: fidl::encoding::Depth,
13962 ) -> fidl::Result<()> {
13963 encoder.debug_check_bounds::<UsageGainListenerOnGainMuteChangedRequest>(offset);
13964 fidl::encoding::Encode::<UsageGainListenerOnGainMuteChangedRequest, D>::encode(
13966 (
13967 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.muted),
13968 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_dbfs),
13969 ),
13970 encoder,
13971 offset,
13972 _depth,
13973 )
13974 }
13975 }
13976 unsafe impl<
13977 D: fidl::encoding::ResourceDialect,
13978 T0: fidl::encoding::Encode<bool, D>,
13979 T1: fidl::encoding::Encode<f32, D>,
13980 > fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D> for (T0, T1)
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::<UsageGainListenerOnGainMuteChangedRequest>(offset);
13990 unsafe {
13993 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
13994 (ptr as *mut u32).write_unaligned(0);
13995 }
13996 self.0.encode(encoder, offset + 0, depth)?;
13998 self.1.encode(encoder, offset + 4, depth)?;
13999 Ok(())
14000 }
14001 }
14002
14003 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14004 for UsageGainListenerOnGainMuteChangedRequest
14005 {
14006 #[inline(always)]
14007 fn new_empty() -> Self {
14008 Self { muted: fidl::new_empty!(bool, D), gain_dbfs: fidl::new_empty!(f32, D) }
14009 }
14010
14011 #[inline]
14012 unsafe fn decode(
14013 &mut self,
14014 decoder: &mut fidl::encoding::Decoder<'_, D>,
14015 offset: usize,
14016 _depth: fidl::encoding::Depth,
14017 ) -> fidl::Result<()> {
14018 decoder.debug_check_bounds::<Self>(offset);
14019 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
14021 let padval = unsafe { (ptr as *const u32).read_unaligned() };
14022 let mask = 0xffffff00u32;
14023 let maskedval = padval & mask;
14024 if maskedval != 0 {
14025 return Err(fidl::Error::NonZeroPadding {
14026 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
14027 });
14028 }
14029 fidl::decode!(bool, D, &mut self.muted, decoder, offset + 0, _depth)?;
14030 fidl::decode!(f32, D, &mut self.gain_dbfs, decoder, offset + 4, _depth)?;
14031 Ok(())
14032 }
14033 }
14034
14035 impl fidl::encoding::ValueTypeMarker for UsageWatcher2OnStateChangedRequest {
14036 type Borrowed<'a> = &'a Self;
14037 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14038 value
14039 }
14040 }
14041
14042 unsafe impl fidl::encoding::TypeMarker for UsageWatcher2OnStateChangedRequest {
14043 type Owned = Self;
14044
14045 #[inline(always)]
14046 fn inline_align(_context: fidl::encoding::Context) -> usize {
14047 8
14048 }
14049
14050 #[inline(always)]
14051 fn inline_size(_context: fidl::encoding::Context) -> usize {
14052 32
14053 }
14054 }
14055
14056 unsafe impl<D: fidl::encoding::ResourceDialect>
14057 fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D>
14058 for &UsageWatcher2OnStateChangedRequest
14059 {
14060 #[inline]
14061 unsafe fn encode(
14062 self,
14063 encoder: &mut fidl::encoding::Encoder<'_, D>,
14064 offset: usize,
14065 _depth: fidl::encoding::Depth,
14066 ) -> fidl::Result<()> {
14067 encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14068 fidl::encoding::Encode::<UsageWatcher2OnStateChangedRequest, D>::encode(
14070 (
14071 <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14072 <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14073 ),
14074 encoder,
14075 offset,
14076 _depth,
14077 )
14078 }
14079 }
14080 unsafe impl<
14081 D: fidl::encoding::ResourceDialect,
14082 T0: fidl::encoding::Encode<Usage2, D>,
14083 T1: fidl::encoding::Encode<UsageState, D>,
14084 > fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D> for (T0, T1)
14085 {
14086 #[inline]
14087 unsafe fn encode(
14088 self,
14089 encoder: &mut fidl::encoding::Encoder<'_, D>,
14090 offset: usize,
14091 depth: fidl::encoding::Depth,
14092 ) -> fidl::Result<()> {
14093 encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14094 self.0.encode(encoder, offset + 0, depth)?;
14098 self.1.encode(encoder, offset + 16, depth)?;
14099 Ok(())
14100 }
14101 }
14102
14103 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14104 for UsageWatcher2OnStateChangedRequest
14105 {
14106 #[inline(always)]
14107 fn new_empty() -> Self {
14108 Self { usage: fidl::new_empty!(Usage2, D), state: fidl::new_empty!(UsageState, D) }
14109 }
14110
14111 #[inline]
14112 unsafe fn decode(
14113 &mut self,
14114 decoder: &mut fidl::encoding::Decoder<'_, D>,
14115 offset: usize,
14116 _depth: fidl::encoding::Depth,
14117 ) -> fidl::Result<()> {
14118 decoder.debug_check_bounds::<Self>(offset);
14119 fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
14121 fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14122 Ok(())
14123 }
14124 }
14125
14126 impl fidl::encoding::ValueTypeMarker for UsageWatcherOnStateChangedRequest {
14127 type Borrowed<'a> = &'a Self;
14128 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14129 value
14130 }
14131 }
14132
14133 unsafe impl fidl::encoding::TypeMarker for UsageWatcherOnStateChangedRequest {
14134 type Owned = Self;
14135
14136 #[inline(always)]
14137 fn inline_align(_context: fidl::encoding::Context) -> usize {
14138 8
14139 }
14140
14141 #[inline(always)]
14142 fn inline_size(_context: fidl::encoding::Context) -> usize {
14143 32
14144 }
14145 }
14146
14147 unsafe impl<D: fidl::encoding::ResourceDialect>
14148 fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D>
14149 for &UsageWatcherOnStateChangedRequest
14150 {
14151 #[inline]
14152 unsafe fn encode(
14153 self,
14154 encoder: &mut fidl::encoding::Encoder<'_, D>,
14155 offset: usize,
14156 _depth: fidl::encoding::Depth,
14157 ) -> fidl::Result<()> {
14158 encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14159 fidl::encoding::Encode::<UsageWatcherOnStateChangedRequest, D>::encode(
14161 (
14162 <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14163 <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14164 ),
14165 encoder,
14166 offset,
14167 _depth,
14168 )
14169 }
14170 }
14171 unsafe impl<
14172 D: fidl::encoding::ResourceDialect,
14173 T0: fidl::encoding::Encode<Usage, D>,
14174 T1: fidl::encoding::Encode<UsageState, D>,
14175 > fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D> for (T0, T1)
14176 {
14177 #[inline]
14178 unsafe fn encode(
14179 self,
14180 encoder: &mut fidl::encoding::Encoder<'_, D>,
14181 offset: usize,
14182 depth: fidl::encoding::Depth,
14183 ) -> fidl::Result<()> {
14184 encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14185 self.0.encode(encoder, offset + 0, depth)?;
14189 self.1.encode(encoder, offset + 16, depth)?;
14190 Ok(())
14191 }
14192 }
14193
14194 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14195 for UsageWatcherOnStateChangedRequest
14196 {
14197 #[inline(always)]
14198 fn new_empty() -> Self {
14199 Self { usage: fidl::new_empty!(Usage, D), state: fidl::new_empty!(UsageState, D) }
14200 }
14201
14202 #[inline]
14203 unsafe fn decode(
14204 &mut self,
14205 decoder: &mut fidl::encoding::Decoder<'_, D>,
14206 offset: usize,
14207 _depth: fidl::encoding::Depth,
14208 ) -> fidl::Result<()> {
14209 decoder.debug_check_bounds::<Self>(offset);
14210 fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
14212 fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14213 Ok(())
14214 }
14215 }
14216
14217 impl fidl::encoding::ValueTypeMarker for VideoStreamType {
14218 type Borrowed<'a> = &'a Self;
14219 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14220 value
14221 }
14222 }
14223
14224 unsafe impl fidl::encoding::TypeMarker for VideoStreamType {
14225 type Owned = Self;
14226
14227 #[inline(always)]
14228 fn inline_align(_context: fidl::encoding::Context) -> usize {
14229 4
14230 }
14231
14232 #[inline(always)]
14233 fn inline_size(_context: fidl::encoding::Context) -> usize {
14234 36
14235 }
14236 }
14237
14238 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoStreamType, D>
14239 for &VideoStreamType
14240 {
14241 #[inline]
14242 unsafe fn encode(
14243 self,
14244 encoder: &mut fidl::encoding::Encoder<'_, D>,
14245 offset: usize,
14246 _depth: fidl::encoding::Depth,
14247 ) -> fidl::Result<()> {
14248 encoder.debug_check_bounds::<VideoStreamType>(offset);
14249 fidl::encoding::Encode::<VideoStreamType, D>::encode(
14251 (
14252 <fidl_fuchsia_images__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
14253 <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
14254 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
14255 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
14256 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_width),
14257 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_height),
14258 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14259 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14260 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.stride),
14261 ),
14262 encoder, offset, _depth
14263 )
14264 }
14265 }
14266 unsafe impl<
14267 D: fidl::encoding::ResourceDialect,
14268 T0: fidl::encoding::Encode<fidl_fuchsia_images__common::PixelFormat, D>,
14269 T1: fidl::encoding::Encode<ColorSpace, D>,
14270 T2: fidl::encoding::Encode<u32, D>,
14271 T3: fidl::encoding::Encode<u32, D>,
14272 T4: fidl::encoding::Encode<u32, D>,
14273 T5: fidl::encoding::Encode<u32, D>,
14274 T6: fidl::encoding::Encode<u32, D>,
14275 T7: fidl::encoding::Encode<u32, D>,
14276 T8: fidl::encoding::Encode<u32, D>,
14277 > fidl::encoding::Encode<VideoStreamType, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
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::<VideoStreamType>(offset);
14287 self.0.encode(encoder, offset + 0, depth)?;
14291 self.1.encode(encoder, offset + 4, depth)?;
14292 self.2.encode(encoder, offset + 8, depth)?;
14293 self.3.encode(encoder, offset + 12, depth)?;
14294 self.4.encode(encoder, offset + 16, depth)?;
14295 self.5.encode(encoder, offset + 20, depth)?;
14296 self.6.encode(encoder, offset + 24, depth)?;
14297 self.7.encode(encoder, offset + 28, depth)?;
14298 self.8.encode(encoder, offset + 32, depth)?;
14299 Ok(())
14300 }
14301 }
14302
14303 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoStreamType {
14304 #[inline(always)]
14305 fn new_empty() -> Self {
14306 Self {
14307 pixel_format: fidl::new_empty!(fidl_fuchsia_images__common::PixelFormat, D),
14308 color_space: fidl::new_empty!(ColorSpace, D),
14309 width: fidl::new_empty!(u32, D),
14310 height: fidl::new_empty!(u32, D),
14311 coded_width: fidl::new_empty!(u32, D),
14312 coded_height: fidl::new_empty!(u32, D),
14313 pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14314 pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14315 stride: fidl::new_empty!(u32, D),
14316 }
14317 }
14318
14319 #[inline]
14320 unsafe fn decode(
14321 &mut self,
14322 decoder: &mut fidl::encoding::Decoder<'_, D>,
14323 offset: usize,
14324 _depth: fidl::encoding::Depth,
14325 ) -> fidl::Result<()> {
14326 decoder.debug_check_bounds::<Self>(offset);
14327 fidl::decode!(
14329 fidl_fuchsia_images__common::PixelFormat,
14330 D,
14331 &mut self.pixel_format,
14332 decoder,
14333 offset + 0,
14334 _depth
14335 )?;
14336 fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 4, _depth)?;
14337 fidl::decode!(u32, D, &mut self.width, decoder, offset + 8, _depth)?;
14338 fidl::decode!(u32, D, &mut self.height, decoder, offset + 12, _depth)?;
14339 fidl::decode!(u32, D, &mut self.coded_width, decoder, offset + 16, _depth)?;
14340 fidl::decode!(u32, D, &mut self.coded_height, decoder, offset + 20, _depth)?;
14341 fidl::decode!(
14342 u32,
14343 D,
14344 &mut self.pixel_aspect_ratio_width,
14345 decoder,
14346 offset + 24,
14347 _depth
14348 )?;
14349 fidl::decode!(
14350 u32,
14351 D,
14352 &mut self.pixel_aspect_ratio_height,
14353 decoder,
14354 offset + 28,
14355 _depth
14356 )?;
14357 fidl::decode!(u32, D, &mut self.stride, decoder, offset + 32, _depth)?;
14358 Ok(())
14359 }
14360 }
14361
14362 impl fidl::encoding::ValueTypeMarker for VideoUncompressedFormat {
14363 type Borrowed<'a> = &'a Self;
14364 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14365 value
14366 }
14367 }
14368
14369 unsafe impl fidl::encoding::TypeMarker for VideoUncompressedFormat {
14370 type Owned = Self;
14371
14372 #[inline(always)]
14373 fn inline_align(_context: fidl::encoding::Context) -> usize {
14374 8
14375 }
14376
14377 #[inline(always)]
14378 fn inline_size(_context: fidl::encoding::Context) -> usize {
14379 128
14380 }
14381 }
14382
14383 unsafe impl<D: fidl::encoding::ResourceDialect>
14384 fidl::encoding::Encode<VideoUncompressedFormat, D> for &VideoUncompressedFormat
14385 {
14386 #[inline]
14387 unsafe fn encode(
14388 self,
14389 encoder: &mut fidl::encoding::Encoder<'_, D>,
14390 offset: usize,
14391 _depth: fidl::encoding::Depth,
14392 ) -> fidl::Result<()> {
14393 encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14394 fidl::encoding::Encode::<VideoUncompressedFormat, D>::encode(
14396 (
14397 <fidl_fuchsia_sysmem__common::ImageFormat2 as fidl::encoding::ValueTypeMarker>::borrow(&self.image_format),
14398 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.fourcc),
14399 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_width_pixels),
14400 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_height_pixels),
14401 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_width_pixels),
14402 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_height_pixels),
14403 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.planar),
14404 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.swizzled),
14405 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_line_stride_bytes),
14406 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_line_stride_bytes),
14407 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_start_offset),
14408 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_start_offset),
14409 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.tertiary_start_offset),
14410 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_pixel_stride),
14411 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_pixel_stride),
14412 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_width_pixels),
14413 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_height_pixels),
14414 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_pixel_aspect_ratio),
14415 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14416 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14417 ),
14418 encoder, offset, _depth
14419 )
14420 }
14421 }
14422 unsafe impl<
14423 D: fidl::encoding::ResourceDialect,
14424 T0: fidl::encoding::Encode<fidl_fuchsia_sysmem__common::ImageFormat2, D>,
14425 T1: fidl::encoding::Encode<u32, D>,
14426 T2: fidl::encoding::Encode<u32, D>,
14427 T3: fidl::encoding::Encode<u32, D>,
14428 T4: fidl::encoding::Encode<u32, D>,
14429 T5: fidl::encoding::Encode<u32, D>,
14430 T6: fidl::encoding::Encode<bool, D>,
14431 T7: fidl::encoding::Encode<bool, D>,
14432 T8: fidl::encoding::Encode<u32, D>,
14433 T9: fidl::encoding::Encode<u32, D>,
14434 T10: fidl::encoding::Encode<u32, D>,
14435 T11: fidl::encoding::Encode<u32, D>,
14436 T12: fidl::encoding::Encode<u32, D>,
14437 T13: fidl::encoding::Encode<u32, D>,
14438 T14: fidl::encoding::Encode<u32, D>,
14439 T15: fidl::encoding::Encode<u32, D>,
14440 T16: fidl::encoding::Encode<u32, D>,
14441 T17: fidl::encoding::Encode<bool, D>,
14442 T18: fidl::encoding::Encode<u32, D>,
14443 T19: fidl::encoding::Encode<u32, D>,
14444 > fidl::encoding::Encode<VideoUncompressedFormat, D>
14445 for (
14446 T0,
14447 T1,
14448 T2,
14449 T3,
14450 T4,
14451 T5,
14452 T6,
14453 T7,
14454 T8,
14455 T9,
14456 T10,
14457 T11,
14458 T12,
14459 T13,
14460 T14,
14461 T15,
14462 T16,
14463 T17,
14464 T18,
14465 T19,
14466 )
14467 {
14468 #[inline]
14469 unsafe fn encode(
14470 self,
14471 encoder: &mut fidl::encoding::Encoder<'_, D>,
14472 offset: usize,
14473 depth: fidl::encoding::Depth,
14474 ) -> fidl::Result<()> {
14475 encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14476 unsafe {
14479 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
14480 (ptr as *mut u64).write_unaligned(0);
14481 }
14482 unsafe {
14483 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
14484 (ptr as *mut u64).write_unaligned(0);
14485 }
14486 self.0.encode(encoder, offset + 0, depth)?;
14488 self.1.encode(encoder, offset + 56, depth)?;
14489 self.2.encode(encoder, offset + 60, depth)?;
14490 self.3.encode(encoder, offset + 64, depth)?;
14491 self.4.encode(encoder, offset + 68, depth)?;
14492 self.5.encode(encoder, offset + 72, depth)?;
14493 self.6.encode(encoder, offset + 76, depth)?;
14494 self.7.encode(encoder, offset + 77, depth)?;
14495 self.8.encode(encoder, offset + 80, depth)?;
14496 self.9.encode(encoder, offset + 84, depth)?;
14497 self.10.encode(encoder, offset + 88, depth)?;
14498 self.11.encode(encoder, offset + 92, depth)?;
14499 self.12.encode(encoder, offset + 96, depth)?;
14500 self.13.encode(encoder, offset + 100, depth)?;
14501 self.14.encode(encoder, offset + 104, depth)?;
14502 self.15.encode(encoder, offset + 108, depth)?;
14503 self.16.encode(encoder, offset + 112, depth)?;
14504 self.17.encode(encoder, offset + 116, depth)?;
14505 self.18.encode(encoder, offset + 120, depth)?;
14506 self.19.encode(encoder, offset + 124, depth)?;
14507 Ok(())
14508 }
14509 }
14510
14511 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14512 for VideoUncompressedFormat
14513 {
14514 #[inline(always)]
14515 fn new_empty() -> Self {
14516 Self {
14517 image_format: fidl::new_empty!(fidl_fuchsia_sysmem__common::ImageFormat2, D),
14518 fourcc: fidl::new_empty!(u32, D),
14519 primary_width_pixels: fidl::new_empty!(u32, D),
14520 primary_height_pixels: fidl::new_empty!(u32, D),
14521 secondary_width_pixels: fidl::new_empty!(u32, D),
14522 secondary_height_pixels: fidl::new_empty!(u32, D),
14523 planar: fidl::new_empty!(bool, D),
14524 swizzled: fidl::new_empty!(bool, D),
14525 primary_line_stride_bytes: fidl::new_empty!(u32, D),
14526 secondary_line_stride_bytes: fidl::new_empty!(u32, D),
14527 primary_start_offset: fidl::new_empty!(u32, D),
14528 secondary_start_offset: fidl::new_empty!(u32, D),
14529 tertiary_start_offset: fidl::new_empty!(u32, D),
14530 primary_pixel_stride: fidl::new_empty!(u32, D),
14531 secondary_pixel_stride: fidl::new_empty!(u32, D),
14532 primary_display_width_pixels: fidl::new_empty!(u32, D),
14533 primary_display_height_pixels: fidl::new_empty!(u32, D),
14534 has_pixel_aspect_ratio: fidl::new_empty!(bool, D),
14535 pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14536 pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14537 }
14538 }
14539
14540 #[inline]
14541 unsafe fn decode(
14542 &mut self,
14543 decoder: &mut fidl::encoding::Decoder<'_, D>,
14544 offset: usize,
14545 _depth: fidl::encoding::Depth,
14546 ) -> fidl::Result<()> {
14547 decoder.debug_check_bounds::<Self>(offset);
14548 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
14550 let padval = unsafe { (ptr as *const u64).read_unaligned() };
14551 let mask = 0xffff000000000000u64;
14552 let maskedval = padval & mask;
14553 if maskedval != 0 {
14554 return Err(fidl::Error::NonZeroPadding {
14555 padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
14556 });
14557 }
14558 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
14559 let padval = unsafe { (ptr as *const u64).read_unaligned() };
14560 let mask = 0xffffff0000000000u64;
14561 let maskedval = padval & mask;
14562 if maskedval != 0 {
14563 return Err(fidl::Error::NonZeroPadding {
14564 padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
14565 });
14566 }
14567 fidl::decode!(
14568 fidl_fuchsia_sysmem__common::ImageFormat2,
14569 D,
14570 &mut self.image_format,
14571 decoder,
14572 offset + 0,
14573 _depth
14574 )?;
14575 fidl::decode!(u32, D, &mut self.fourcc, decoder, offset + 56, _depth)?;
14576 fidl::decode!(u32, D, &mut self.primary_width_pixels, decoder, offset + 60, _depth)?;
14577 fidl::decode!(u32, D, &mut self.primary_height_pixels, decoder, offset + 64, _depth)?;
14578 fidl::decode!(u32, D, &mut self.secondary_width_pixels, decoder, offset + 68, _depth)?;
14579 fidl::decode!(u32, D, &mut self.secondary_height_pixels, decoder, offset + 72, _depth)?;
14580 fidl::decode!(bool, D, &mut self.planar, decoder, offset + 76, _depth)?;
14581 fidl::decode!(bool, D, &mut self.swizzled, decoder, offset + 77, _depth)?;
14582 fidl::decode!(
14583 u32,
14584 D,
14585 &mut self.primary_line_stride_bytes,
14586 decoder,
14587 offset + 80,
14588 _depth
14589 )?;
14590 fidl::decode!(
14591 u32,
14592 D,
14593 &mut self.secondary_line_stride_bytes,
14594 decoder,
14595 offset + 84,
14596 _depth
14597 )?;
14598 fidl::decode!(u32, D, &mut self.primary_start_offset, decoder, offset + 88, _depth)?;
14599 fidl::decode!(u32, D, &mut self.secondary_start_offset, decoder, offset + 92, _depth)?;
14600 fidl::decode!(u32, D, &mut self.tertiary_start_offset, decoder, offset + 96, _depth)?;
14601 fidl::decode!(u32, D, &mut self.primary_pixel_stride, decoder, offset + 100, _depth)?;
14602 fidl::decode!(u32, D, &mut self.secondary_pixel_stride, decoder, offset + 104, _depth)?;
14603 fidl::decode!(
14604 u32,
14605 D,
14606 &mut self.primary_display_width_pixels,
14607 decoder,
14608 offset + 108,
14609 _depth
14610 )?;
14611 fidl::decode!(
14612 u32,
14613 D,
14614 &mut self.primary_display_height_pixels,
14615 decoder,
14616 offset + 112,
14617 _depth
14618 )?;
14619 fidl::decode!(
14620 bool,
14621 D,
14622 &mut self.has_pixel_aspect_ratio,
14623 decoder,
14624 offset + 116,
14625 _depth
14626 )?;
14627 fidl::decode!(
14628 u32,
14629 D,
14630 &mut self.pixel_aspect_ratio_width,
14631 decoder,
14632 offset + 120,
14633 _depth
14634 )?;
14635 fidl::decode!(
14636 u32,
14637 D,
14638 &mut self.pixel_aspect_ratio_height,
14639 decoder,
14640 offset + 124,
14641 _depth
14642 )?;
14643 Ok(())
14644 }
14645 }
14646
14647 impl fidl::encoding::ValueTypeMarker for Void {
14648 type Borrowed<'a> = &'a Self;
14649 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14650 value
14651 }
14652 }
14653
14654 unsafe impl fidl::encoding::TypeMarker for Void {
14655 type Owned = Self;
14656
14657 #[inline(always)]
14658 fn inline_align(_context: fidl::encoding::Context) -> usize {
14659 1
14660 }
14661
14662 #[inline(always)]
14663 fn inline_size(_context: fidl::encoding::Context) -> usize {
14664 1
14665 }
14666 }
14667
14668 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
14669 #[inline]
14670 unsafe fn encode(
14671 self,
14672 encoder: &mut fidl::encoding::Encoder<'_, D>,
14673 offset: usize,
14674 _depth: fidl::encoding::Depth,
14675 ) -> fidl::Result<()> {
14676 encoder.debug_check_bounds::<Void>(offset);
14677 encoder.write_num(0u8, offset);
14678 Ok(())
14679 }
14680 }
14681
14682 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
14683 #[inline(always)]
14684 fn new_empty() -> Self {
14685 Self
14686 }
14687
14688 #[inline]
14689 unsafe fn decode(
14690 &mut self,
14691 decoder: &mut fidl::encoding::Decoder<'_, D>,
14692 offset: usize,
14693 _depth: fidl::encoding::Depth,
14694 ) -> fidl::Result<()> {
14695 decoder.debug_check_bounds::<Self>(offset);
14696 match decoder.read_num::<u8>(offset) {
14697 0 => Ok(()),
14698 _ => Err(fidl::Error::Invalid),
14699 }
14700 }
14701 }
14702
14703 impl AudioCompressedFormatCvsd {
14704 #[inline(always)]
14705 fn max_ordinal_present(&self) -> u64 {
14706 0
14707 }
14708 }
14709
14710 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatCvsd {
14711 type Borrowed<'a> = &'a Self;
14712 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14713 value
14714 }
14715 }
14716
14717 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatCvsd {
14718 type Owned = Self;
14719
14720 #[inline(always)]
14721 fn inline_align(_context: fidl::encoding::Context) -> usize {
14722 8
14723 }
14724
14725 #[inline(always)]
14726 fn inline_size(_context: fidl::encoding::Context) -> usize {
14727 16
14728 }
14729 }
14730
14731 unsafe impl<D: fidl::encoding::ResourceDialect>
14732 fidl::encoding::Encode<AudioCompressedFormatCvsd, D> for &AudioCompressedFormatCvsd
14733 {
14734 unsafe fn encode(
14735 self,
14736 encoder: &mut fidl::encoding::Encoder<'_, D>,
14737 offset: usize,
14738 mut depth: fidl::encoding::Depth,
14739 ) -> fidl::Result<()> {
14740 encoder.debug_check_bounds::<AudioCompressedFormatCvsd>(offset);
14741 let max_ordinal: u64 = self.max_ordinal_present();
14743 encoder.write_num(max_ordinal, offset);
14744 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14745 if max_ordinal == 0 {
14747 return Ok(());
14748 }
14749 depth.increment()?;
14750 let envelope_size = 8;
14751 let bytes_len = max_ordinal as usize * envelope_size;
14752 #[allow(unused_variables)]
14753 let offset = encoder.out_of_line_offset(bytes_len);
14754 let mut _prev_end_offset: usize = 0;
14755
14756 Ok(())
14757 }
14758 }
14759
14760 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14761 for AudioCompressedFormatCvsd
14762 {
14763 #[inline(always)]
14764 fn new_empty() -> Self {
14765 Self::default()
14766 }
14767
14768 unsafe fn decode(
14769 &mut self,
14770 decoder: &mut fidl::encoding::Decoder<'_, D>,
14771 offset: usize,
14772 mut depth: fidl::encoding::Depth,
14773 ) -> fidl::Result<()> {
14774 decoder.debug_check_bounds::<Self>(offset);
14775 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14776 None => return Err(fidl::Error::NotNullable),
14777 Some(len) => len,
14778 };
14779 if len == 0 {
14781 return Ok(());
14782 };
14783 depth.increment()?;
14784 let envelope_size = 8;
14785 let bytes_len = len * envelope_size;
14786 let offset = decoder.out_of_line_offset(bytes_len)?;
14787 let mut _next_ordinal_to_read = 0;
14789 let mut next_offset = offset;
14790 let end_offset = offset + bytes_len;
14791
14792 while next_offset < end_offset {
14794 _next_ordinal_to_read += 1;
14795 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14796 next_offset += envelope_size;
14797 }
14798
14799 Ok(())
14800 }
14801 }
14802
14803 impl AudioCompressedFormatLc3 {
14804 #[inline(always)]
14805 fn max_ordinal_present(&self) -> u64 {
14806 0
14807 }
14808 }
14809
14810 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatLc3 {
14811 type Borrowed<'a> = &'a Self;
14812 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14813 value
14814 }
14815 }
14816
14817 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatLc3 {
14818 type Owned = Self;
14819
14820 #[inline(always)]
14821 fn inline_align(_context: fidl::encoding::Context) -> usize {
14822 8
14823 }
14824
14825 #[inline(always)]
14826 fn inline_size(_context: fidl::encoding::Context) -> usize {
14827 16
14828 }
14829 }
14830
14831 unsafe impl<D: fidl::encoding::ResourceDialect>
14832 fidl::encoding::Encode<AudioCompressedFormatLc3, D> for &AudioCompressedFormatLc3
14833 {
14834 unsafe fn encode(
14835 self,
14836 encoder: &mut fidl::encoding::Encoder<'_, D>,
14837 offset: usize,
14838 mut depth: fidl::encoding::Depth,
14839 ) -> fidl::Result<()> {
14840 encoder.debug_check_bounds::<AudioCompressedFormatLc3>(offset);
14841 let max_ordinal: u64 = self.max_ordinal_present();
14843 encoder.write_num(max_ordinal, offset);
14844 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14845 if max_ordinal == 0 {
14847 return Ok(());
14848 }
14849 depth.increment()?;
14850 let envelope_size = 8;
14851 let bytes_len = max_ordinal as usize * envelope_size;
14852 #[allow(unused_variables)]
14853 let offset = encoder.out_of_line_offset(bytes_len);
14854 let mut _prev_end_offset: usize = 0;
14855
14856 Ok(())
14857 }
14858 }
14859
14860 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14861 for AudioCompressedFormatLc3
14862 {
14863 #[inline(always)]
14864 fn new_empty() -> Self {
14865 Self::default()
14866 }
14867
14868 unsafe fn decode(
14869 &mut self,
14870 decoder: &mut fidl::encoding::Decoder<'_, D>,
14871 offset: usize,
14872 mut depth: fidl::encoding::Depth,
14873 ) -> fidl::Result<()> {
14874 decoder.debug_check_bounds::<Self>(offset);
14875 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14876 None => return Err(fidl::Error::NotNullable),
14877 Some(len) => len,
14878 };
14879 if len == 0 {
14881 return Ok(());
14882 };
14883 depth.increment()?;
14884 let envelope_size = 8;
14885 let bytes_len = len * envelope_size;
14886 let offset = decoder.out_of_line_offset(bytes_len)?;
14887 let mut _next_ordinal_to_read = 0;
14889 let mut next_offset = offset;
14890 let end_offset = offset + bytes_len;
14891
14892 while next_offset < end_offset {
14894 _next_ordinal_to_read += 1;
14895 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14896 next_offset += envelope_size;
14897 }
14898
14899 Ok(())
14900 }
14901 }
14902
14903 impl AudioConsumerStatus {
14904 #[inline(always)]
14905 fn max_ordinal_present(&self) -> u64 {
14906 if let Some(_) = self.max_lead_time {
14907 return 4;
14908 }
14909 if let Some(_) = self.min_lead_time {
14910 return 3;
14911 }
14912 if let Some(_) = self.presentation_timeline {
14913 return 2;
14914 }
14915 if let Some(_) = self.error {
14916 return 1;
14917 }
14918 0
14919 }
14920 }
14921
14922 impl fidl::encoding::ValueTypeMarker for AudioConsumerStatus {
14923 type Borrowed<'a> = &'a Self;
14924 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14925 value
14926 }
14927 }
14928
14929 unsafe impl fidl::encoding::TypeMarker for AudioConsumerStatus {
14930 type Owned = Self;
14931
14932 #[inline(always)]
14933 fn inline_align(_context: fidl::encoding::Context) -> usize {
14934 8
14935 }
14936
14937 #[inline(always)]
14938 fn inline_size(_context: fidl::encoding::Context) -> usize {
14939 16
14940 }
14941 }
14942
14943 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerStatus, D>
14944 for &AudioConsumerStatus
14945 {
14946 unsafe fn encode(
14947 self,
14948 encoder: &mut fidl::encoding::Encoder<'_, D>,
14949 offset: usize,
14950 mut depth: fidl::encoding::Depth,
14951 ) -> fidl::Result<()> {
14952 encoder.debug_check_bounds::<AudioConsumerStatus>(offset);
14953 let max_ordinal: u64 = self.max_ordinal_present();
14955 encoder.write_num(max_ordinal, offset);
14956 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14957 if max_ordinal == 0 {
14959 return Ok(());
14960 }
14961 depth.increment()?;
14962 let envelope_size = 8;
14963 let bytes_len = max_ordinal as usize * envelope_size;
14964 #[allow(unused_variables)]
14965 let offset = encoder.out_of_line_offset(bytes_len);
14966 let mut _prev_end_offset: usize = 0;
14967 if 1 > max_ordinal {
14968 return Ok(());
14969 }
14970
14971 let cur_offset: usize = (1 - 1) * envelope_size;
14974
14975 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14977
14978 fidl::encoding::encode_in_envelope_optional::<AudioConsumerError, D>(
14983 self.error
14984 .as_ref()
14985 .map(<AudioConsumerError as fidl::encoding::ValueTypeMarker>::borrow),
14986 encoder,
14987 offset + cur_offset,
14988 depth,
14989 )?;
14990
14991 _prev_end_offset = cur_offset + envelope_size;
14992 if 2 > max_ordinal {
14993 return Ok(());
14994 }
14995
14996 let cur_offset: usize = (2 - 1) * envelope_size;
14999
15000 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15002
15003 fidl::encoding::encode_in_envelope_optional::<TimelineFunction, D>(
15008 self.presentation_timeline
15009 .as_ref()
15010 .map(<TimelineFunction as fidl::encoding::ValueTypeMarker>::borrow),
15011 encoder,
15012 offset + cur_offset,
15013 depth,
15014 )?;
15015
15016 _prev_end_offset = cur_offset + envelope_size;
15017 if 3 > max_ordinal {
15018 return Ok(());
15019 }
15020
15021 let cur_offset: usize = (3 - 1) * envelope_size;
15024
15025 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15027
15028 fidl::encoding::encode_in_envelope_optional::<u64, D>(
15033 self.min_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15034 encoder,
15035 offset + cur_offset,
15036 depth,
15037 )?;
15038
15039 _prev_end_offset = cur_offset + envelope_size;
15040 if 4 > max_ordinal {
15041 return Ok(());
15042 }
15043
15044 let cur_offset: usize = (4 - 1) * envelope_size;
15047
15048 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15050
15051 fidl::encoding::encode_in_envelope_optional::<u64, D>(
15056 self.max_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15057 encoder,
15058 offset + cur_offset,
15059 depth,
15060 )?;
15061
15062 _prev_end_offset = cur_offset + envelope_size;
15063
15064 Ok(())
15065 }
15066 }
15067
15068 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerStatus {
15069 #[inline(always)]
15070 fn new_empty() -> Self {
15071 Self::default()
15072 }
15073
15074 unsafe fn decode(
15075 &mut self,
15076 decoder: &mut fidl::encoding::Decoder<'_, D>,
15077 offset: usize,
15078 mut depth: fidl::encoding::Depth,
15079 ) -> fidl::Result<()> {
15080 decoder.debug_check_bounds::<Self>(offset);
15081 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15082 None => return Err(fidl::Error::NotNullable),
15083 Some(len) => len,
15084 };
15085 if len == 0 {
15087 return Ok(());
15088 };
15089 depth.increment()?;
15090 let envelope_size = 8;
15091 let bytes_len = len * envelope_size;
15092 let offset = decoder.out_of_line_offset(bytes_len)?;
15093 let mut _next_ordinal_to_read = 0;
15095 let mut next_offset = offset;
15096 let end_offset = offset + bytes_len;
15097 _next_ordinal_to_read += 1;
15098 if next_offset >= end_offset {
15099 return Ok(());
15100 }
15101
15102 while _next_ordinal_to_read < 1 {
15104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15105 _next_ordinal_to_read += 1;
15106 next_offset += envelope_size;
15107 }
15108
15109 let next_out_of_line = decoder.next_out_of_line();
15110 let handles_before = decoder.remaining_handles();
15111 if let Some((inlined, num_bytes, num_handles)) =
15112 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15113 {
15114 let member_inline_size =
15115 <AudioConsumerError as fidl::encoding::TypeMarker>::inline_size(
15116 decoder.context,
15117 );
15118 if inlined != (member_inline_size <= 4) {
15119 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15120 }
15121 let inner_offset;
15122 let mut inner_depth = depth.clone();
15123 if inlined {
15124 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15125 inner_offset = next_offset;
15126 } else {
15127 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15128 inner_depth.increment()?;
15129 }
15130 let val_ref =
15131 self.error.get_or_insert_with(|| fidl::new_empty!(AudioConsumerError, D));
15132 fidl::decode!(AudioConsumerError, D, val_ref, decoder, inner_offset, inner_depth)?;
15133 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15134 {
15135 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15136 }
15137 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15138 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15139 }
15140 }
15141
15142 next_offset += envelope_size;
15143 _next_ordinal_to_read += 1;
15144 if next_offset >= end_offset {
15145 return Ok(());
15146 }
15147
15148 while _next_ordinal_to_read < 2 {
15150 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15151 _next_ordinal_to_read += 1;
15152 next_offset += envelope_size;
15153 }
15154
15155 let next_out_of_line = decoder.next_out_of_line();
15156 let handles_before = decoder.remaining_handles();
15157 if let Some((inlined, num_bytes, num_handles)) =
15158 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15159 {
15160 let member_inline_size =
15161 <TimelineFunction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15162 if inlined != (member_inline_size <= 4) {
15163 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15164 }
15165 let inner_offset;
15166 let mut inner_depth = depth.clone();
15167 if inlined {
15168 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15169 inner_offset = next_offset;
15170 } else {
15171 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15172 inner_depth.increment()?;
15173 }
15174 let val_ref = self
15175 .presentation_timeline
15176 .get_or_insert_with(|| fidl::new_empty!(TimelineFunction, D));
15177 fidl::decode!(TimelineFunction, D, val_ref, decoder, inner_offset, inner_depth)?;
15178 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15179 {
15180 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15181 }
15182 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15183 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15184 }
15185 }
15186
15187 next_offset += envelope_size;
15188 _next_ordinal_to_read += 1;
15189 if next_offset >= end_offset {
15190 return Ok(());
15191 }
15192
15193 while _next_ordinal_to_read < 3 {
15195 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15196 _next_ordinal_to_read += 1;
15197 next_offset += envelope_size;
15198 }
15199
15200 let next_out_of_line = decoder.next_out_of_line();
15201 let handles_before = decoder.remaining_handles();
15202 if let Some((inlined, num_bytes, num_handles)) =
15203 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15204 {
15205 let member_inline_size =
15206 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15207 if inlined != (member_inline_size <= 4) {
15208 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15209 }
15210 let inner_offset;
15211 let mut inner_depth = depth.clone();
15212 if inlined {
15213 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15214 inner_offset = next_offset;
15215 } else {
15216 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15217 inner_depth.increment()?;
15218 }
15219 let val_ref = self.min_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15220 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15221 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15222 {
15223 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15224 }
15225 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15226 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15227 }
15228 }
15229
15230 next_offset += envelope_size;
15231 _next_ordinal_to_read += 1;
15232 if next_offset >= end_offset {
15233 return Ok(());
15234 }
15235
15236 while _next_ordinal_to_read < 4 {
15238 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15239 _next_ordinal_to_read += 1;
15240 next_offset += envelope_size;
15241 }
15242
15243 let next_out_of_line = decoder.next_out_of_line();
15244 let handles_before = decoder.remaining_handles();
15245 if let Some((inlined, num_bytes, num_handles)) =
15246 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15247 {
15248 let member_inline_size =
15249 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15250 if inlined != (member_inline_size <= 4) {
15251 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15252 }
15253 let inner_offset;
15254 let mut inner_depth = depth.clone();
15255 if inlined {
15256 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15257 inner_offset = next_offset;
15258 } else {
15259 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15260 inner_depth.increment()?;
15261 }
15262 let val_ref = self.max_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15263 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15264 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15265 {
15266 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15267 }
15268 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15269 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15270 }
15271 }
15272
15273 next_offset += envelope_size;
15274
15275 while next_offset < end_offset {
15277 _next_ordinal_to_read += 1;
15278 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15279 next_offset += envelope_size;
15280 }
15281
15282 Ok(())
15283 }
15284 }
15285
15286 impl CvsdEncoderSettings {
15287 #[inline(always)]
15288 fn max_ordinal_present(&self) -> u64 {
15289 0
15290 }
15291 }
15292
15293 impl fidl::encoding::ValueTypeMarker for CvsdEncoderSettings {
15294 type Borrowed<'a> = &'a Self;
15295 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15296 value
15297 }
15298 }
15299
15300 unsafe impl fidl::encoding::TypeMarker for CvsdEncoderSettings {
15301 type Owned = Self;
15302
15303 #[inline(always)]
15304 fn inline_align(_context: fidl::encoding::Context) -> usize {
15305 8
15306 }
15307
15308 #[inline(always)]
15309 fn inline_size(_context: fidl::encoding::Context) -> usize {
15310 16
15311 }
15312 }
15313
15314 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CvsdEncoderSettings, D>
15315 for &CvsdEncoderSettings
15316 {
15317 unsafe fn encode(
15318 self,
15319 encoder: &mut fidl::encoding::Encoder<'_, D>,
15320 offset: usize,
15321 mut depth: fidl::encoding::Depth,
15322 ) -> fidl::Result<()> {
15323 encoder.debug_check_bounds::<CvsdEncoderSettings>(offset);
15324 let max_ordinal: u64 = self.max_ordinal_present();
15326 encoder.write_num(max_ordinal, offset);
15327 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15328 if max_ordinal == 0 {
15330 return Ok(());
15331 }
15332 depth.increment()?;
15333 let envelope_size = 8;
15334 let bytes_len = max_ordinal as usize * envelope_size;
15335 #[allow(unused_variables)]
15336 let offset = encoder.out_of_line_offset(bytes_len);
15337 let mut _prev_end_offset: usize = 0;
15338
15339 Ok(())
15340 }
15341 }
15342
15343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CvsdEncoderSettings {
15344 #[inline(always)]
15345 fn new_empty() -> Self {
15346 Self::default()
15347 }
15348
15349 unsafe fn decode(
15350 &mut self,
15351 decoder: &mut fidl::encoding::Decoder<'_, D>,
15352 offset: usize,
15353 mut depth: fidl::encoding::Depth,
15354 ) -> fidl::Result<()> {
15355 decoder.debug_check_bounds::<Self>(offset);
15356 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15357 None => return Err(fidl::Error::NotNullable),
15358 Some(len) => len,
15359 };
15360 if len == 0 {
15362 return Ok(());
15363 };
15364 depth.increment()?;
15365 let envelope_size = 8;
15366 let bytes_len = len * envelope_size;
15367 let offset = decoder.out_of_line_offset(bytes_len)?;
15368 let mut _next_ordinal_to_read = 0;
15370 let mut next_offset = offset;
15371 let end_offset = offset + bytes_len;
15372
15373 while next_offset < end_offset {
15375 _next_ordinal_to_read += 1;
15376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15377 next_offset += envelope_size;
15378 }
15379
15380 Ok(())
15381 }
15382 }
15383
15384 impl DecryptedFormat {
15385 #[inline(always)]
15386 fn max_ordinal_present(&self) -> u64 {
15387 if let Some(_) = self.ignore_this_field {
15388 return 1;
15389 }
15390 0
15391 }
15392 }
15393
15394 impl fidl::encoding::ValueTypeMarker for DecryptedFormat {
15395 type Borrowed<'a> = &'a Self;
15396 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15397 value
15398 }
15399 }
15400
15401 unsafe impl fidl::encoding::TypeMarker for DecryptedFormat {
15402 type Owned = Self;
15403
15404 #[inline(always)]
15405 fn inline_align(_context: fidl::encoding::Context) -> usize {
15406 8
15407 }
15408
15409 #[inline(always)]
15410 fn inline_size(_context: fidl::encoding::Context) -> usize {
15411 16
15412 }
15413 }
15414
15415 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DecryptedFormat, D>
15416 for &DecryptedFormat
15417 {
15418 unsafe fn encode(
15419 self,
15420 encoder: &mut fidl::encoding::Encoder<'_, D>,
15421 offset: usize,
15422 mut depth: fidl::encoding::Depth,
15423 ) -> fidl::Result<()> {
15424 encoder.debug_check_bounds::<DecryptedFormat>(offset);
15425 let max_ordinal: u64 = self.max_ordinal_present();
15427 encoder.write_num(max_ordinal, offset);
15428 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15429 if max_ordinal == 0 {
15431 return Ok(());
15432 }
15433 depth.increment()?;
15434 let envelope_size = 8;
15435 let bytes_len = max_ordinal as usize * envelope_size;
15436 #[allow(unused_variables)]
15437 let offset = encoder.out_of_line_offset(bytes_len);
15438 let mut _prev_end_offset: usize = 0;
15439 if 1 > max_ordinal {
15440 return Ok(());
15441 }
15442
15443 let cur_offset: usize = (1 - 1) * envelope_size;
15446
15447 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15449
15450 fidl::encoding::encode_in_envelope_optional::<bool, D>(
15455 self.ignore_this_field
15456 .as_ref()
15457 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
15458 encoder,
15459 offset + cur_offset,
15460 depth,
15461 )?;
15462
15463 _prev_end_offset = cur_offset + envelope_size;
15464
15465 Ok(())
15466 }
15467 }
15468
15469 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DecryptedFormat {
15470 #[inline(always)]
15471 fn new_empty() -> Self {
15472 Self::default()
15473 }
15474
15475 unsafe fn decode(
15476 &mut self,
15477 decoder: &mut fidl::encoding::Decoder<'_, D>,
15478 offset: usize,
15479 mut depth: fidl::encoding::Depth,
15480 ) -> fidl::Result<()> {
15481 decoder.debug_check_bounds::<Self>(offset);
15482 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15483 None => return Err(fidl::Error::NotNullable),
15484 Some(len) => len,
15485 };
15486 if len == 0 {
15488 return Ok(());
15489 };
15490 depth.increment()?;
15491 let envelope_size = 8;
15492 let bytes_len = len * envelope_size;
15493 let offset = decoder.out_of_line_offset(bytes_len)?;
15494 let mut _next_ordinal_to_read = 0;
15496 let mut next_offset = offset;
15497 let end_offset = offset + bytes_len;
15498 _next_ordinal_to_read += 1;
15499 if next_offset >= end_offset {
15500 return Ok(());
15501 }
15502
15503 while _next_ordinal_to_read < 1 {
15505 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15506 _next_ordinal_to_read += 1;
15507 next_offset += envelope_size;
15508 }
15509
15510 let next_out_of_line = decoder.next_out_of_line();
15511 let handles_before = decoder.remaining_handles();
15512 if let Some((inlined, num_bytes, num_handles)) =
15513 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15514 {
15515 let member_inline_size =
15516 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15517 if inlined != (member_inline_size <= 4) {
15518 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15519 }
15520 let inner_offset;
15521 let mut inner_depth = depth.clone();
15522 if inlined {
15523 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15524 inner_offset = next_offset;
15525 } else {
15526 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15527 inner_depth.increment()?;
15528 }
15529 let val_ref =
15530 self.ignore_this_field.get_or_insert_with(|| fidl::new_empty!(bool, D));
15531 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
15532 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15533 {
15534 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15535 }
15536 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15537 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15538 }
15539 }
15540
15541 next_offset += envelope_size;
15542
15543 while next_offset < end_offset {
15545 _next_ordinal_to_read += 1;
15546 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15547 next_offset += envelope_size;
15548 }
15549
15550 Ok(())
15551 }
15552 }
15553
15554 impl EncryptedFormat {
15555 #[inline(always)]
15556 fn max_ordinal_present(&self) -> u64 {
15557 if let Some(_) = self.key_id {
15558 return 8;
15559 }
15560 if let Some(_) = self.scheme {
15561 return 6;
15562 }
15563 if let Some(_) = self.pattern {
15564 return 5;
15565 }
15566 if let Some(_) = self.subsamples {
15567 return 4;
15568 }
15569 if let Some(_) = self.init_vector {
15570 return 3;
15571 }
15572 0
15573 }
15574 }
15575
15576 impl fidl::encoding::ValueTypeMarker for EncryptedFormat {
15577 type Borrowed<'a> = &'a Self;
15578 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15579 value
15580 }
15581 }
15582
15583 unsafe impl fidl::encoding::TypeMarker for EncryptedFormat {
15584 type Owned = Self;
15585
15586 #[inline(always)]
15587 fn inline_align(_context: fidl::encoding::Context) -> usize {
15588 8
15589 }
15590
15591 #[inline(always)]
15592 fn inline_size(_context: fidl::encoding::Context) -> usize {
15593 16
15594 }
15595 }
15596
15597 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptedFormat, D>
15598 for &EncryptedFormat
15599 {
15600 unsafe fn encode(
15601 self,
15602 encoder: &mut fidl::encoding::Encoder<'_, D>,
15603 offset: usize,
15604 mut depth: fidl::encoding::Depth,
15605 ) -> fidl::Result<()> {
15606 encoder.debug_check_bounds::<EncryptedFormat>(offset);
15607 let max_ordinal: u64 = self.max_ordinal_present();
15609 encoder.write_num(max_ordinal, offset);
15610 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15611 if max_ordinal == 0 {
15613 return Ok(());
15614 }
15615 depth.increment()?;
15616 let envelope_size = 8;
15617 let bytes_len = max_ordinal as usize * envelope_size;
15618 #[allow(unused_variables)]
15619 let offset = encoder.out_of_line_offset(bytes_len);
15620 let mut _prev_end_offset: usize = 0;
15621 if 3 > max_ordinal {
15622 return Ok(());
15623 }
15624
15625 let cur_offset: usize = (3 - 1) * envelope_size;
15628
15629 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15631
15632 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15637 self.init_vector.as_ref().map(
15638 <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15639 ),
15640 encoder,
15641 offset + cur_offset,
15642 depth,
15643 )?;
15644
15645 _prev_end_offset = cur_offset + envelope_size;
15646 if 4 > max_ordinal {
15647 return Ok(());
15648 }
15649
15650 let cur_offset: usize = (4 - 1) * envelope_size;
15653
15654 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15656
15657 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<SubsampleEntry>, D>(
15662 self.subsamples.as_ref().map(<fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::ValueTypeMarker>::borrow),
15663 encoder, offset + cur_offset, depth
15664 )?;
15665
15666 _prev_end_offset = cur_offset + envelope_size;
15667 if 5 > max_ordinal {
15668 return Ok(());
15669 }
15670
15671 let cur_offset: usize = (5 - 1) * envelope_size;
15674
15675 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15677
15678 fidl::encoding::encode_in_envelope_optional::<EncryptionPattern, D>(
15683 self.pattern
15684 .as_ref()
15685 .map(<EncryptionPattern as fidl::encoding::ValueTypeMarker>::borrow),
15686 encoder,
15687 offset + cur_offset,
15688 depth,
15689 )?;
15690
15691 _prev_end_offset = cur_offset + envelope_size;
15692 if 6 > max_ordinal {
15693 return Ok(());
15694 }
15695
15696 let cur_offset: usize = (6 - 1) * envelope_size;
15699
15700 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15702
15703 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
15708 self.scheme.as_ref().map(
15709 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
15710 ),
15711 encoder,
15712 offset + cur_offset,
15713 depth,
15714 )?;
15715
15716 _prev_end_offset = cur_offset + envelope_size;
15717 if 8 > max_ordinal {
15718 return Ok(());
15719 }
15720
15721 let cur_offset: usize = (8 - 1) * envelope_size;
15724
15725 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15727
15728 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15733 self.key_id.as_ref().map(
15734 <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15735 ),
15736 encoder,
15737 offset + cur_offset,
15738 depth,
15739 )?;
15740
15741 _prev_end_offset = cur_offset + envelope_size;
15742
15743 Ok(())
15744 }
15745 }
15746
15747 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptedFormat {
15748 #[inline(always)]
15749 fn new_empty() -> Self {
15750 Self::default()
15751 }
15752
15753 unsafe fn decode(
15754 &mut self,
15755 decoder: &mut fidl::encoding::Decoder<'_, D>,
15756 offset: usize,
15757 mut depth: fidl::encoding::Depth,
15758 ) -> fidl::Result<()> {
15759 decoder.debug_check_bounds::<Self>(offset);
15760 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15761 None => return Err(fidl::Error::NotNullable),
15762 Some(len) => len,
15763 };
15764 if len == 0 {
15766 return Ok(());
15767 };
15768 depth.increment()?;
15769 let envelope_size = 8;
15770 let bytes_len = len * envelope_size;
15771 let offset = decoder.out_of_line_offset(bytes_len)?;
15772 let mut _next_ordinal_to_read = 0;
15774 let mut next_offset = offset;
15775 let end_offset = offset + bytes_len;
15776 _next_ordinal_to_read += 1;
15777 if next_offset >= end_offset {
15778 return Ok(());
15779 }
15780
15781 while _next_ordinal_to_read < 3 {
15783 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15784 _next_ordinal_to_read += 1;
15785 next_offset += envelope_size;
15786 }
15787
15788 let next_out_of_line = decoder.next_out_of_line();
15789 let handles_before = decoder.remaining_handles();
15790 if let Some((inlined, num_bytes, num_handles)) =
15791 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15792 {
15793 let member_inline_size =
15794 <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
15795 decoder.context,
15796 );
15797 if inlined != (member_inline_size <= 4) {
15798 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15799 }
15800 let inner_offset;
15801 let mut inner_depth = depth.clone();
15802 if inlined {
15803 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15804 inner_offset = next_offset;
15805 } else {
15806 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15807 inner_depth.increment()?;
15808 }
15809 let val_ref = self
15810 .init_vector
15811 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
15812 fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
15813 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15814 {
15815 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15816 }
15817 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15818 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15819 }
15820 }
15821
15822 next_offset += envelope_size;
15823 _next_ordinal_to_read += 1;
15824 if next_offset >= end_offset {
15825 return Ok(());
15826 }
15827
15828 while _next_ordinal_to_read < 4 {
15830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15831 _next_ordinal_to_read += 1;
15832 next_offset += envelope_size;
15833 }
15834
15835 let next_out_of_line = decoder.next_out_of_line();
15836 let handles_before = decoder.remaining_handles();
15837 if let Some((inlined, num_bytes, num_handles)) =
15838 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15839 {
15840 let member_inline_size = <fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15841 if inlined != (member_inline_size <= 4) {
15842 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15843 }
15844 let inner_offset;
15845 let mut inner_depth = depth.clone();
15846 if inlined {
15847 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15848 inner_offset = next_offset;
15849 } else {
15850 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15851 inner_depth.increment()?;
15852 }
15853 let val_ref = self.subsamples.get_or_insert_with(|| {
15854 fidl::new_empty!(fidl::encoding::UnboundedVector<SubsampleEntry>, D)
15855 });
15856 fidl::decode!(
15857 fidl::encoding::UnboundedVector<SubsampleEntry>,
15858 D,
15859 val_ref,
15860 decoder,
15861 inner_offset,
15862 inner_depth
15863 )?;
15864 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15865 {
15866 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15867 }
15868 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15869 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15870 }
15871 }
15872
15873 next_offset += envelope_size;
15874 _next_ordinal_to_read += 1;
15875 if next_offset >= end_offset {
15876 return Ok(());
15877 }
15878
15879 while _next_ordinal_to_read < 5 {
15881 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15882 _next_ordinal_to_read += 1;
15883 next_offset += envelope_size;
15884 }
15885
15886 let next_out_of_line = decoder.next_out_of_line();
15887 let handles_before = decoder.remaining_handles();
15888 if let Some((inlined, num_bytes, num_handles)) =
15889 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15890 {
15891 let member_inline_size =
15892 <EncryptionPattern as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15893 if inlined != (member_inline_size <= 4) {
15894 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15895 }
15896 let inner_offset;
15897 let mut inner_depth = depth.clone();
15898 if inlined {
15899 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15900 inner_offset = next_offset;
15901 } else {
15902 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15903 inner_depth.increment()?;
15904 }
15905 let val_ref =
15906 self.pattern.get_or_insert_with(|| fidl::new_empty!(EncryptionPattern, D));
15907 fidl::decode!(EncryptionPattern, D, val_ref, decoder, inner_offset, inner_depth)?;
15908 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15909 {
15910 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15911 }
15912 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15913 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15914 }
15915 }
15916
15917 next_offset += envelope_size;
15918 _next_ordinal_to_read += 1;
15919 if next_offset >= end_offset {
15920 return Ok(());
15921 }
15922
15923 while _next_ordinal_to_read < 6 {
15925 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15926 _next_ordinal_to_read += 1;
15927 next_offset += envelope_size;
15928 }
15929
15930 let next_out_of_line = decoder.next_out_of_line();
15931 let handles_before = decoder.remaining_handles();
15932 if let Some((inlined, num_bytes, num_handles)) =
15933 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15934 {
15935 let member_inline_size =
15936 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15937 decoder.context,
15938 );
15939 if inlined != (member_inline_size <= 4) {
15940 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15941 }
15942 let inner_offset;
15943 let mut inner_depth = depth.clone();
15944 if inlined {
15945 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15946 inner_offset = next_offset;
15947 } else {
15948 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15949 inner_depth.increment()?;
15950 }
15951 let val_ref = self
15952 .scheme
15953 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
15954 fidl::decode!(
15955 fidl::encoding::UnboundedString,
15956 D,
15957 val_ref,
15958 decoder,
15959 inner_offset,
15960 inner_depth
15961 )?;
15962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15963 {
15964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15965 }
15966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15968 }
15969 }
15970
15971 next_offset += envelope_size;
15972 _next_ordinal_to_read += 1;
15973 if next_offset >= end_offset {
15974 return Ok(());
15975 }
15976
15977 while _next_ordinal_to_read < 8 {
15979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15980 _next_ordinal_to_read += 1;
15981 next_offset += envelope_size;
15982 }
15983
15984 let next_out_of_line = decoder.next_out_of_line();
15985 let handles_before = decoder.remaining_handles();
15986 if let Some((inlined, num_bytes, num_handles)) =
15987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15988 {
15989 let member_inline_size =
15990 <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
15991 decoder.context,
15992 );
15993 if inlined != (member_inline_size <= 4) {
15994 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15995 }
15996 let inner_offset;
15997 let mut inner_depth = depth.clone();
15998 if inlined {
15999 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16000 inner_offset = next_offset;
16001 } else {
16002 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16003 inner_depth.increment()?;
16004 }
16005 let val_ref = self
16006 .key_id
16007 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
16008 fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
16009 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16010 {
16011 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16012 }
16013 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16014 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16015 }
16016 }
16017
16018 next_offset += envelope_size;
16019
16020 while next_offset < end_offset {
16022 _next_ordinal_to_read += 1;
16023 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16024 next_offset += envelope_size;
16025 }
16026
16027 Ok(())
16028 }
16029 }
16030
16031 impl FormatDetails {
16032 #[inline(always)]
16033 fn max_ordinal_present(&self) -> u64 {
16034 if let Some(_) = self.profile {
16035 return 8;
16036 }
16037 if let Some(_) = self.timebase {
16038 return 7;
16039 }
16040 if let Some(_) = self.encoder_settings {
16041 return 6;
16042 }
16043 if let Some(_) = self.pass_through_parameters {
16044 return 5;
16045 }
16046 if let Some(_) = self.domain {
16047 return 4;
16048 }
16049 if let Some(_) = self.oob_bytes {
16050 return 3;
16051 }
16052 if let Some(_) = self.mime_type {
16053 return 2;
16054 }
16055 if let Some(_) = self.format_details_version_ordinal {
16056 return 1;
16057 }
16058 0
16059 }
16060 }
16061
16062 impl fidl::encoding::ValueTypeMarker for FormatDetails {
16063 type Borrowed<'a> = &'a Self;
16064 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16065 value
16066 }
16067 }
16068
16069 unsafe impl fidl::encoding::TypeMarker for FormatDetails {
16070 type Owned = Self;
16071
16072 #[inline(always)]
16073 fn inline_align(_context: fidl::encoding::Context) -> usize {
16074 8
16075 }
16076
16077 #[inline(always)]
16078 fn inline_size(_context: fidl::encoding::Context) -> usize {
16079 16
16080 }
16081 }
16082
16083 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatDetails, D>
16084 for &FormatDetails
16085 {
16086 unsafe fn encode(
16087 self,
16088 encoder: &mut fidl::encoding::Encoder<'_, D>,
16089 offset: usize,
16090 mut depth: fidl::encoding::Depth,
16091 ) -> fidl::Result<()> {
16092 encoder.debug_check_bounds::<FormatDetails>(offset);
16093 let max_ordinal: u64 = self.max_ordinal_present();
16095 encoder.write_num(max_ordinal, offset);
16096 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16097 if max_ordinal == 0 {
16099 return Ok(());
16100 }
16101 depth.increment()?;
16102 let envelope_size = 8;
16103 let bytes_len = max_ordinal as usize * envelope_size;
16104 #[allow(unused_variables)]
16105 let offset = encoder.out_of_line_offset(bytes_len);
16106 let mut _prev_end_offset: usize = 0;
16107 if 1 > max_ordinal {
16108 return Ok(());
16109 }
16110
16111 let cur_offset: usize = (1 - 1) * envelope_size;
16114
16115 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16117
16118 fidl::encoding::encode_in_envelope_optional::<u64, D>(
16123 self.format_details_version_ordinal
16124 .as_ref()
16125 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16126 encoder,
16127 offset + cur_offset,
16128 depth,
16129 )?;
16130
16131 _prev_end_offset = cur_offset + envelope_size;
16132 if 2 > max_ordinal {
16133 return Ok(());
16134 }
16135
16136 let cur_offset: usize = (2 - 1) * envelope_size;
16139
16140 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16142
16143 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
16148 self.mime_type.as_ref().map(
16149 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
16150 ),
16151 encoder,
16152 offset + cur_offset,
16153 depth,
16154 )?;
16155
16156 _prev_end_offset = cur_offset + envelope_size;
16157 if 3 > max_ordinal {
16158 return Ok(());
16159 }
16160
16161 let cur_offset: usize = (3 - 1) * envelope_size;
16164
16165 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16167
16168 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
16173 self.oob_bytes.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
16174 encoder, offset + cur_offset, depth
16175 )?;
16176
16177 _prev_end_offset = cur_offset + envelope_size;
16178 if 4 > max_ordinal {
16179 return Ok(());
16180 }
16181
16182 let cur_offset: usize = (4 - 1) * envelope_size;
16185
16186 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16188
16189 fidl::encoding::encode_in_envelope_optional::<DomainFormat, D>(
16194 self.domain.as_ref().map(<DomainFormat as fidl::encoding::ValueTypeMarker>::borrow),
16195 encoder,
16196 offset + cur_offset,
16197 depth,
16198 )?;
16199
16200 _prev_end_offset = cur_offset + envelope_size;
16201 if 5 > max_ordinal {
16202 return Ok(());
16203 }
16204
16205 let cur_offset: usize = (5 - 1) * envelope_size;
16208
16209 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16211
16212 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Parameter>, D>(
16217 self.pass_through_parameters.as_ref().map(<fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::ValueTypeMarker>::borrow),
16218 encoder, offset + cur_offset, depth
16219 )?;
16220
16221 _prev_end_offset = cur_offset + envelope_size;
16222 if 6 > max_ordinal {
16223 return Ok(());
16224 }
16225
16226 let cur_offset: usize = (6 - 1) * envelope_size;
16229
16230 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16232
16233 fidl::encoding::encode_in_envelope_optional::<EncoderSettings, D>(
16238 self.encoder_settings
16239 .as_ref()
16240 .map(<EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow),
16241 encoder,
16242 offset + cur_offset,
16243 depth,
16244 )?;
16245
16246 _prev_end_offset = cur_offset + envelope_size;
16247 if 7 > max_ordinal {
16248 return Ok(());
16249 }
16250
16251 let cur_offset: usize = (7 - 1) * envelope_size;
16254
16255 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16257
16258 fidl::encoding::encode_in_envelope_optional::<u64, D>(
16263 self.timebase.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16264 encoder,
16265 offset + cur_offset,
16266 depth,
16267 )?;
16268
16269 _prev_end_offset = cur_offset + envelope_size;
16270 if 8 > max_ordinal {
16271 return Ok(());
16272 }
16273
16274 let cur_offset: usize = (8 - 1) * envelope_size;
16277
16278 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16280
16281 fidl::encoding::encode_in_envelope_optional::<CodecProfile, D>(
16286 self.profile
16287 .as_ref()
16288 .map(<CodecProfile as fidl::encoding::ValueTypeMarker>::borrow),
16289 encoder,
16290 offset + cur_offset,
16291 depth,
16292 )?;
16293
16294 _prev_end_offset = cur_offset + envelope_size;
16295
16296 Ok(())
16297 }
16298 }
16299
16300 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatDetails {
16301 #[inline(always)]
16302 fn new_empty() -> Self {
16303 Self::default()
16304 }
16305
16306 unsafe fn decode(
16307 &mut self,
16308 decoder: &mut fidl::encoding::Decoder<'_, D>,
16309 offset: usize,
16310 mut depth: fidl::encoding::Depth,
16311 ) -> fidl::Result<()> {
16312 decoder.debug_check_bounds::<Self>(offset);
16313 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16314 None => return Err(fidl::Error::NotNullable),
16315 Some(len) => len,
16316 };
16317 if len == 0 {
16319 return Ok(());
16320 };
16321 depth.increment()?;
16322 let envelope_size = 8;
16323 let bytes_len = len * envelope_size;
16324 let offset = decoder.out_of_line_offset(bytes_len)?;
16325 let mut _next_ordinal_to_read = 0;
16327 let mut next_offset = offset;
16328 let end_offset = offset + bytes_len;
16329 _next_ordinal_to_read += 1;
16330 if next_offset >= end_offset {
16331 return Ok(());
16332 }
16333
16334 while _next_ordinal_to_read < 1 {
16336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16337 _next_ordinal_to_read += 1;
16338 next_offset += envelope_size;
16339 }
16340
16341 let next_out_of_line = decoder.next_out_of_line();
16342 let handles_before = decoder.remaining_handles();
16343 if let Some((inlined, num_bytes, num_handles)) =
16344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16345 {
16346 let member_inline_size =
16347 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16348 if inlined != (member_inline_size <= 4) {
16349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16350 }
16351 let inner_offset;
16352 let mut inner_depth = depth.clone();
16353 if inlined {
16354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16355 inner_offset = next_offset;
16356 } else {
16357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16358 inner_depth.increment()?;
16359 }
16360 let val_ref = self
16361 .format_details_version_ordinal
16362 .get_or_insert_with(|| fidl::new_empty!(u64, D));
16363 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16364 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16365 {
16366 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16367 }
16368 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16369 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16370 }
16371 }
16372
16373 next_offset += envelope_size;
16374 _next_ordinal_to_read += 1;
16375 if next_offset >= end_offset {
16376 return Ok(());
16377 }
16378
16379 while _next_ordinal_to_read < 2 {
16381 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16382 _next_ordinal_to_read += 1;
16383 next_offset += envelope_size;
16384 }
16385
16386 let next_out_of_line = decoder.next_out_of_line();
16387 let handles_before = decoder.remaining_handles();
16388 if let Some((inlined, num_bytes, num_handles)) =
16389 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16390 {
16391 let member_inline_size =
16392 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
16393 decoder.context,
16394 );
16395 if inlined != (member_inline_size <= 4) {
16396 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16397 }
16398 let inner_offset;
16399 let mut inner_depth = depth.clone();
16400 if inlined {
16401 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16402 inner_offset = next_offset;
16403 } else {
16404 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16405 inner_depth.increment()?;
16406 }
16407 let val_ref = self
16408 .mime_type
16409 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
16410 fidl::decode!(
16411 fidl::encoding::UnboundedString,
16412 D,
16413 val_ref,
16414 decoder,
16415 inner_offset,
16416 inner_depth
16417 )?;
16418 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16419 {
16420 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16421 }
16422 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16423 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16424 }
16425 }
16426
16427 next_offset += envelope_size;
16428 _next_ordinal_to_read += 1;
16429 if next_offset >= end_offset {
16430 return Ok(());
16431 }
16432
16433 while _next_ordinal_to_read < 3 {
16435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16436 _next_ordinal_to_read += 1;
16437 next_offset += envelope_size;
16438 }
16439
16440 let next_out_of_line = decoder.next_out_of_line();
16441 let handles_before = decoder.remaining_handles();
16442 if let Some((inlined, num_bytes, num_handles)) =
16443 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16444 {
16445 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16446 if inlined != (member_inline_size <= 4) {
16447 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16448 }
16449 let inner_offset;
16450 let mut inner_depth = depth.clone();
16451 if inlined {
16452 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16453 inner_offset = next_offset;
16454 } else {
16455 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16456 inner_depth.increment()?;
16457 }
16458 let val_ref = self.oob_bytes.get_or_insert_with(|| {
16459 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
16460 });
16461 fidl::decode!(
16462 fidl::encoding::UnboundedVector<u8>,
16463 D,
16464 val_ref,
16465 decoder,
16466 inner_offset,
16467 inner_depth
16468 )?;
16469 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16470 {
16471 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16472 }
16473 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16474 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16475 }
16476 }
16477
16478 next_offset += envelope_size;
16479 _next_ordinal_to_read += 1;
16480 if next_offset >= end_offset {
16481 return Ok(());
16482 }
16483
16484 while _next_ordinal_to_read < 4 {
16486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16487 _next_ordinal_to_read += 1;
16488 next_offset += envelope_size;
16489 }
16490
16491 let next_out_of_line = decoder.next_out_of_line();
16492 let handles_before = decoder.remaining_handles();
16493 if let Some((inlined, num_bytes, num_handles)) =
16494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16495 {
16496 let member_inline_size =
16497 <DomainFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16498 if inlined != (member_inline_size <= 4) {
16499 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16500 }
16501 let inner_offset;
16502 let mut inner_depth = depth.clone();
16503 if inlined {
16504 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16505 inner_offset = next_offset;
16506 } else {
16507 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16508 inner_depth.increment()?;
16509 }
16510 let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(DomainFormat, D));
16511 fidl::decode!(DomainFormat, D, val_ref, decoder, inner_offset, inner_depth)?;
16512 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16513 {
16514 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16515 }
16516 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16517 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16518 }
16519 }
16520
16521 next_offset += envelope_size;
16522 _next_ordinal_to_read += 1;
16523 if next_offset >= end_offset {
16524 return Ok(());
16525 }
16526
16527 while _next_ordinal_to_read < 5 {
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 = <fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16540 if inlined != (member_inline_size <= 4) {
16541 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16542 }
16543 let inner_offset;
16544 let mut inner_depth = depth.clone();
16545 if inlined {
16546 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16547 inner_offset = next_offset;
16548 } else {
16549 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16550 inner_depth.increment()?;
16551 }
16552 let val_ref = self.pass_through_parameters.get_or_insert_with(|| {
16553 fidl::new_empty!(fidl::encoding::UnboundedVector<Parameter>, D)
16554 });
16555 fidl::decode!(
16556 fidl::encoding::UnboundedVector<Parameter>,
16557 D,
16558 val_ref,
16559 decoder,
16560 inner_offset,
16561 inner_depth
16562 )?;
16563 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16564 {
16565 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16566 }
16567 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16568 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16569 }
16570 }
16571
16572 next_offset += envelope_size;
16573 _next_ordinal_to_read += 1;
16574 if next_offset >= end_offset {
16575 return Ok(());
16576 }
16577
16578 while _next_ordinal_to_read < 6 {
16580 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16581 _next_ordinal_to_read += 1;
16582 next_offset += envelope_size;
16583 }
16584
16585 let next_out_of_line = decoder.next_out_of_line();
16586 let handles_before = decoder.remaining_handles();
16587 if let Some((inlined, num_bytes, num_handles)) =
16588 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16589 {
16590 let member_inline_size =
16591 <EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16592 if inlined != (member_inline_size <= 4) {
16593 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16594 }
16595 let inner_offset;
16596 let mut inner_depth = depth.clone();
16597 if inlined {
16598 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16599 inner_offset = next_offset;
16600 } else {
16601 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16602 inner_depth.increment()?;
16603 }
16604 let val_ref = self
16605 .encoder_settings
16606 .get_or_insert_with(|| fidl::new_empty!(EncoderSettings, D));
16607 fidl::decode!(EncoderSettings, D, val_ref, decoder, inner_offset, inner_depth)?;
16608 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16609 {
16610 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16611 }
16612 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16613 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16614 }
16615 }
16616
16617 next_offset += envelope_size;
16618 _next_ordinal_to_read += 1;
16619 if next_offset >= end_offset {
16620 return Ok(());
16621 }
16622
16623 while _next_ordinal_to_read < 7 {
16625 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16626 _next_ordinal_to_read += 1;
16627 next_offset += envelope_size;
16628 }
16629
16630 let next_out_of_line = decoder.next_out_of_line();
16631 let handles_before = decoder.remaining_handles();
16632 if let Some((inlined, num_bytes, num_handles)) =
16633 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16634 {
16635 let member_inline_size =
16636 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16637 if inlined != (member_inline_size <= 4) {
16638 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16639 }
16640 let inner_offset;
16641 let mut inner_depth = depth.clone();
16642 if inlined {
16643 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16644 inner_offset = next_offset;
16645 } else {
16646 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16647 inner_depth.increment()?;
16648 }
16649 let val_ref = self.timebase.get_or_insert_with(|| fidl::new_empty!(u64, D));
16650 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16651 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16652 {
16653 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16654 }
16655 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16656 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16657 }
16658 }
16659
16660 next_offset += envelope_size;
16661 _next_ordinal_to_read += 1;
16662 if next_offset >= end_offset {
16663 return Ok(());
16664 }
16665
16666 while _next_ordinal_to_read < 8 {
16668 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16669 _next_ordinal_to_read += 1;
16670 next_offset += envelope_size;
16671 }
16672
16673 let next_out_of_line = decoder.next_out_of_line();
16674 let handles_before = decoder.remaining_handles();
16675 if let Some((inlined, num_bytes, num_handles)) =
16676 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16677 {
16678 let member_inline_size =
16679 <CodecProfile as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16680 if inlined != (member_inline_size <= 4) {
16681 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16682 }
16683 let inner_offset;
16684 let mut inner_depth = depth.clone();
16685 if inlined {
16686 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16687 inner_offset = next_offset;
16688 } else {
16689 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16690 inner_depth.increment()?;
16691 }
16692 let val_ref = self.profile.get_or_insert_with(|| fidl::new_empty!(CodecProfile, D));
16693 fidl::decode!(CodecProfile, D, val_ref, decoder, inner_offset, inner_depth)?;
16694 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16695 {
16696 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16697 }
16698 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16699 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16700 }
16701 }
16702
16703 next_offset += envelope_size;
16704
16705 while next_offset < end_offset {
16707 _next_ordinal_to_read += 1;
16708 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16709 next_offset += envelope_size;
16710 }
16711
16712 Ok(())
16713 }
16714 }
16715
16716 impl H264EncoderSettings {
16717 #[inline(always)]
16718 fn max_ordinal_present(&self) -> u64 {
16719 if let Some(_) = self.quantization_params {
16720 return 7;
16721 }
16722 if let Some(_) = self.force_key_frame {
16723 return 6;
16724 }
16725 if let Some(_) = self.min_frame_rate {
16726 return 5;
16727 }
16728 if let Some(_) = self.variable_frame_rate {
16729 return 4;
16730 }
16731 if let Some(_) = self.gop_size {
16732 return 3;
16733 }
16734 if let Some(_) = self.frame_rate {
16735 return 2;
16736 }
16737 if let Some(_) = self.bit_rate {
16738 return 1;
16739 }
16740 0
16741 }
16742 }
16743
16744 impl fidl::encoding::ValueTypeMarker for H264EncoderSettings {
16745 type Borrowed<'a> = &'a Self;
16746 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16747 value
16748 }
16749 }
16750
16751 unsafe impl fidl::encoding::TypeMarker for H264EncoderSettings {
16752 type Owned = Self;
16753
16754 #[inline(always)]
16755 fn inline_align(_context: fidl::encoding::Context) -> usize {
16756 8
16757 }
16758
16759 #[inline(always)]
16760 fn inline_size(_context: fidl::encoding::Context) -> usize {
16761 16
16762 }
16763 }
16764
16765 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<H264EncoderSettings, D>
16766 for &H264EncoderSettings
16767 {
16768 unsafe fn encode(
16769 self,
16770 encoder: &mut fidl::encoding::Encoder<'_, D>,
16771 offset: usize,
16772 mut depth: fidl::encoding::Depth,
16773 ) -> fidl::Result<()> {
16774 encoder.debug_check_bounds::<H264EncoderSettings>(offset);
16775 let max_ordinal: u64 = self.max_ordinal_present();
16777 encoder.write_num(max_ordinal, offset);
16778 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16779 if max_ordinal == 0 {
16781 return Ok(());
16782 }
16783 depth.increment()?;
16784 let envelope_size = 8;
16785 let bytes_len = max_ordinal as usize * envelope_size;
16786 #[allow(unused_variables)]
16787 let offset = encoder.out_of_line_offset(bytes_len);
16788 let mut _prev_end_offset: usize = 0;
16789 if 1 > max_ordinal {
16790 return Ok(());
16791 }
16792
16793 let cur_offset: usize = (1 - 1) * envelope_size;
16796
16797 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16799
16800 fidl::encoding::encode_in_envelope_optional::<u32, D>(
16805 self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16806 encoder,
16807 offset + cur_offset,
16808 depth,
16809 )?;
16810
16811 _prev_end_offset = cur_offset + envelope_size;
16812 if 2 > max_ordinal {
16813 return Ok(());
16814 }
16815
16816 let cur_offset: usize = (2 - 1) * envelope_size;
16819
16820 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16822
16823 fidl::encoding::encode_in_envelope_optional::<u32, D>(
16828 self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16829 encoder,
16830 offset + cur_offset,
16831 depth,
16832 )?;
16833
16834 _prev_end_offset = cur_offset + envelope_size;
16835 if 3 > max_ordinal {
16836 return Ok(());
16837 }
16838
16839 let cur_offset: usize = (3 - 1) * envelope_size;
16842
16843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16845
16846 fidl::encoding::encode_in_envelope_optional::<u32, D>(
16851 self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16852 encoder,
16853 offset + cur_offset,
16854 depth,
16855 )?;
16856
16857 _prev_end_offset = cur_offset + envelope_size;
16858 if 4 > max_ordinal {
16859 return Ok(());
16860 }
16861
16862 let cur_offset: usize = (4 - 1) * envelope_size;
16865
16866 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16868
16869 fidl::encoding::encode_in_envelope_optional::<bool, D>(
16874 self.variable_frame_rate
16875 .as_ref()
16876 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
16877 encoder,
16878 offset + cur_offset,
16879 depth,
16880 )?;
16881
16882 _prev_end_offset = cur_offset + envelope_size;
16883 if 5 > max_ordinal {
16884 return Ok(());
16885 }
16886
16887 let cur_offset: usize = (5 - 1) * envelope_size;
16890
16891 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16893
16894 fidl::encoding::encode_in_envelope_optional::<u32, D>(
16899 self.min_frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16900 encoder,
16901 offset + cur_offset,
16902 depth,
16903 )?;
16904
16905 _prev_end_offset = cur_offset + envelope_size;
16906 if 6 > max_ordinal {
16907 return Ok(());
16908 }
16909
16910 let cur_offset: usize = (6 - 1) * envelope_size;
16913
16914 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16916
16917 fidl::encoding::encode_in_envelope_optional::<bool, D>(
16922 self.force_key_frame
16923 .as_ref()
16924 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
16925 encoder,
16926 offset + cur_offset,
16927 depth,
16928 )?;
16929
16930 _prev_end_offset = cur_offset + envelope_size;
16931 if 7 > max_ordinal {
16932 return Ok(());
16933 }
16934
16935 let cur_offset: usize = (7 - 1) * envelope_size;
16938
16939 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16941
16942 fidl::encoding::encode_in_envelope_optional::<H264QuantizationParameters, D>(
16947 self.quantization_params
16948 .as_ref()
16949 .map(<H264QuantizationParameters as fidl::encoding::ValueTypeMarker>::borrow),
16950 encoder,
16951 offset + cur_offset,
16952 depth,
16953 )?;
16954
16955 _prev_end_offset = cur_offset + envelope_size;
16956
16957 Ok(())
16958 }
16959 }
16960
16961 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for H264EncoderSettings {
16962 #[inline(always)]
16963 fn new_empty() -> Self {
16964 Self::default()
16965 }
16966
16967 unsafe fn decode(
16968 &mut self,
16969 decoder: &mut fidl::encoding::Decoder<'_, D>,
16970 offset: usize,
16971 mut depth: fidl::encoding::Depth,
16972 ) -> fidl::Result<()> {
16973 decoder.debug_check_bounds::<Self>(offset);
16974 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16975 None => return Err(fidl::Error::NotNullable),
16976 Some(len) => len,
16977 };
16978 if len == 0 {
16980 return Ok(());
16981 };
16982 depth.increment()?;
16983 let envelope_size = 8;
16984 let bytes_len = len * envelope_size;
16985 let offset = decoder.out_of_line_offset(bytes_len)?;
16986 let mut _next_ordinal_to_read = 0;
16988 let mut next_offset = offset;
16989 let end_offset = offset + bytes_len;
16990 _next_ordinal_to_read += 1;
16991 if next_offset >= end_offset {
16992 return Ok(());
16993 }
16994
16995 while _next_ordinal_to_read < 1 {
16997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16998 _next_ordinal_to_read += 1;
16999 next_offset += envelope_size;
17000 }
17001
17002 let next_out_of_line = decoder.next_out_of_line();
17003 let handles_before = decoder.remaining_handles();
17004 if let Some((inlined, num_bytes, num_handles)) =
17005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17006 {
17007 let member_inline_size =
17008 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17009 if inlined != (member_inline_size <= 4) {
17010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17011 }
17012 let inner_offset;
17013 let mut inner_depth = depth.clone();
17014 if inlined {
17015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17016 inner_offset = next_offset;
17017 } else {
17018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17019 inner_depth.increment()?;
17020 }
17021 let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17022 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17023 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17024 {
17025 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17026 }
17027 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17028 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17029 }
17030 }
17031
17032 next_offset += envelope_size;
17033 _next_ordinal_to_read += 1;
17034 if next_offset >= end_offset {
17035 return Ok(());
17036 }
17037
17038 while _next_ordinal_to_read < 2 {
17040 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17041 _next_ordinal_to_read += 1;
17042 next_offset += envelope_size;
17043 }
17044
17045 let next_out_of_line = decoder.next_out_of_line();
17046 let handles_before = decoder.remaining_handles();
17047 if let Some((inlined, num_bytes, num_handles)) =
17048 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17049 {
17050 let member_inline_size =
17051 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17052 if inlined != (member_inline_size <= 4) {
17053 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17054 }
17055 let inner_offset;
17056 let mut inner_depth = depth.clone();
17057 if inlined {
17058 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17059 inner_offset = next_offset;
17060 } else {
17061 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17062 inner_depth.increment()?;
17063 }
17064 let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17065 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17066 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17067 {
17068 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17069 }
17070 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17071 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17072 }
17073 }
17074
17075 next_offset += envelope_size;
17076 _next_ordinal_to_read += 1;
17077 if next_offset >= end_offset {
17078 return Ok(());
17079 }
17080
17081 while _next_ordinal_to_read < 3 {
17083 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17084 _next_ordinal_to_read += 1;
17085 next_offset += envelope_size;
17086 }
17087
17088 let next_out_of_line = decoder.next_out_of_line();
17089 let handles_before = decoder.remaining_handles();
17090 if let Some((inlined, num_bytes, num_handles)) =
17091 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17092 {
17093 let member_inline_size =
17094 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17095 if inlined != (member_inline_size <= 4) {
17096 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17097 }
17098 let inner_offset;
17099 let mut inner_depth = depth.clone();
17100 if inlined {
17101 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17102 inner_offset = next_offset;
17103 } else {
17104 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17105 inner_depth.increment()?;
17106 }
17107 let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
17108 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17109 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17110 {
17111 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17112 }
17113 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17114 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17115 }
17116 }
17117
17118 next_offset += envelope_size;
17119 _next_ordinal_to_read += 1;
17120 if next_offset >= end_offset {
17121 return Ok(());
17122 }
17123
17124 while _next_ordinal_to_read < 4 {
17126 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17127 _next_ordinal_to_read += 1;
17128 next_offset += envelope_size;
17129 }
17130
17131 let next_out_of_line = decoder.next_out_of_line();
17132 let handles_before = decoder.remaining_handles();
17133 if let Some((inlined, num_bytes, num_handles)) =
17134 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17135 {
17136 let member_inline_size =
17137 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17138 if inlined != (member_inline_size <= 4) {
17139 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17140 }
17141 let inner_offset;
17142 let mut inner_depth = depth.clone();
17143 if inlined {
17144 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17145 inner_offset = next_offset;
17146 } else {
17147 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17148 inner_depth.increment()?;
17149 }
17150 let val_ref =
17151 self.variable_frame_rate.get_or_insert_with(|| fidl::new_empty!(bool, D));
17152 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17153 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17154 {
17155 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17156 }
17157 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17158 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17159 }
17160 }
17161
17162 next_offset += envelope_size;
17163 _next_ordinal_to_read += 1;
17164 if next_offset >= end_offset {
17165 return Ok(());
17166 }
17167
17168 while _next_ordinal_to_read < 5 {
17170 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17171 _next_ordinal_to_read += 1;
17172 next_offset += envelope_size;
17173 }
17174
17175 let next_out_of_line = decoder.next_out_of_line();
17176 let handles_before = decoder.remaining_handles();
17177 if let Some((inlined, num_bytes, num_handles)) =
17178 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17179 {
17180 let member_inline_size =
17181 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17182 if inlined != (member_inline_size <= 4) {
17183 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17184 }
17185 let inner_offset;
17186 let mut inner_depth = depth.clone();
17187 if inlined {
17188 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17189 inner_offset = next_offset;
17190 } else {
17191 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17192 inner_depth.increment()?;
17193 }
17194 let val_ref = self.min_frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17195 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17196 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17197 {
17198 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17199 }
17200 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17201 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17202 }
17203 }
17204
17205 next_offset += envelope_size;
17206 _next_ordinal_to_read += 1;
17207 if next_offset >= end_offset {
17208 return Ok(());
17209 }
17210
17211 while _next_ordinal_to_read < 6 {
17213 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17214 _next_ordinal_to_read += 1;
17215 next_offset += envelope_size;
17216 }
17217
17218 let next_out_of_line = decoder.next_out_of_line();
17219 let handles_before = decoder.remaining_handles();
17220 if let Some((inlined, num_bytes, num_handles)) =
17221 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17222 {
17223 let member_inline_size =
17224 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17225 if inlined != (member_inline_size <= 4) {
17226 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17227 }
17228 let inner_offset;
17229 let mut inner_depth = depth.clone();
17230 if inlined {
17231 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17232 inner_offset = next_offset;
17233 } else {
17234 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17235 inner_depth.increment()?;
17236 }
17237 let val_ref = self.force_key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
17238 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17239 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17240 {
17241 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17242 }
17243 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17244 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17245 }
17246 }
17247
17248 next_offset += envelope_size;
17249 _next_ordinal_to_read += 1;
17250 if next_offset >= end_offset {
17251 return Ok(());
17252 }
17253
17254 while _next_ordinal_to_read < 7 {
17256 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17257 _next_ordinal_to_read += 1;
17258 next_offset += envelope_size;
17259 }
17260
17261 let next_out_of_line = decoder.next_out_of_line();
17262 let handles_before = decoder.remaining_handles();
17263 if let Some((inlined, num_bytes, num_handles)) =
17264 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17265 {
17266 let member_inline_size =
17267 <H264QuantizationParameters as fidl::encoding::TypeMarker>::inline_size(
17268 decoder.context,
17269 );
17270 if inlined != (member_inline_size <= 4) {
17271 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17272 }
17273 let inner_offset;
17274 let mut inner_depth = depth.clone();
17275 if inlined {
17276 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17277 inner_offset = next_offset;
17278 } else {
17279 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17280 inner_depth.increment()?;
17281 }
17282 let val_ref = self
17283 .quantization_params
17284 .get_or_insert_with(|| fidl::new_empty!(H264QuantizationParameters, D));
17285 fidl::decode!(
17286 H264QuantizationParameters,
17287 D,
17288 val_ref,
17289 decoder,
17290 inner_offset,
17291 inner_depth
17292 )?;
17293 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17294 {
17295 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17296 }
17297 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17298 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17299 }
17300 }
17301
17302 next_offset += envelope_size;
17303
17304 while next_offset < end_offset {
17306 _next_ordinal_to_read += 1;
17307 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17308 next_offset += envelope_size;
17309 }
17310
17311 Ok(())
17312 }
17313 }
17314
17315 impl H264QuantizationParameters {
17316 #[inline(always)]
17317 fn max_ordinal_present(&self) -> u64 {
17318 if let Some(_) = self.p_max {
17319 return 6;
17320 }
17321 if let Some(_) = self.p_min {
17322 return 5;
17323 }
17324 if let Some(_) = self.p_base {
17325 return 4;
17326 }
17327 if let Some(_) = self.i_max {
17328 return 3;
17329 }
17330 if let Some(_) = self.i_min {
17331 return 2;
17332 }
17333 if let Some(_) = self.i_base {
17334 return 1;
17335 }
17336 0
17337 }
17338 }
17339
17340 impl fidl::encoding::ValueTypeMarker for H264QuantizationParameters {
17341 type Borrowed<'a> = &'a Self;
17342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17343 value
17344 }
17345 }
17346
17347 unsafe impl fidl::encoding::TypeMarker for H264QuantizationParameters {
17348 type Owned = Self;
17349
17350 #[inline(always)]
17351 fn inline_align(_context: fidl::encoding::Context) -> usize {
17352 8
17353 }
17354
17355 #[inline(always)]
17356 fn inline_size(_context: fidl::encoding::Context) -> usize {
17357 16
17358 }
17359 }
17360
17361 unsafe impl<D: fidl::encoding::ResourceDialect>
17362 fidl::encoding::Encode<H264QuantizationParameters, D> for &H264QuantizationParameters
17363 {
17364 unsafe fn encode(
17365 self,
17366 encoder: &mut fidl::encoding::Encoder<'_, D>,
17367 offset: usize,
17368 mut depth: fidl::encoding::Depth,
17369 ) -> fidl::Result<()> {
17370 encoder.debug_check_bounds::<H264QuantizationParameters>(offset);
17371 let max_ordinal: u64 = self.max_ordinal_present();
17373 encoder.write_num(max_ordinal, offset);
17374 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17375 if max_ordinal == 0 {
17377 return Ok(());
17378 }
17379 depth.increment()?;
17380 let envelope_size = 8;
17381 let bytes_len = max_ordinal as usize * envelope_size;
17382 #[allow(unused_variables)]
17383 let offset = encoder.out_of_line_offset(bytes_len);
17384 let mut _prev_end_offset: usize = 0;
17385 if 1 > max_ordinal {
17386 return Ok(());
17387 }
17388
17389 let cur_offset: usize = (1 - 1) * envelope_size;
17392
17393 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17395
17396 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17401 self.i_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17402 encoder,
17403 offset + cur_offset,
17404 depth,
17405 )?;
17406
17407 _prev_end_offset = cur_offset + envelope_size;
17408 if 2 > max_ordinal {
17409 return Ok(());
17410 }
17411
17412 let cur_offset: usize = (2 - 1) * envelope_size;
17415
17416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17418
17419 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17424 self.i_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17425 encoder,
17426 offset + cur_offset,
17427 depth,
17428 )?;
17429
17430 _prev_end_offset = cur_offset + envelope_size;
17431 if 3 > max_ordinal {
17432 return Ok(());
17433 }
17434
17435 let cur_offset: usize = (3 - 1) * envelope_size;
17438
17439 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17441
17442 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17447 self.i_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17448 encoder,
17449 offset + cur_offset,
17450 depth,
17451 )?;
17452
17453 _prev_end_offset = cur_offset + envelope_size;
17454 if 4 > max_ordinal {
17455 return Ok(());
17456 }
17457
17458 let cur_offset: usize = (4 - 1) * envelope_size;
17461
17462 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17464
17465 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17470 self.p_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17471 encoder,
17472 offset + cur_offset,
17473 depth,
17474 )?;
17475
17476 _prev_end_offset = cur_offset + envelope_size;
17477 if 5 > max_ordinal {
17478 return Ok(());
17479 }
17480
17481 let cur_offset: usize = (5 - 1) * envelope_size;
17484
17485 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17487
17488 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17493 self.p_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17494 encoder,
17495 offset + cur_offset,
17496 depth,
17497 )?;
17498
17499 _prev_end_offset = cur_offset + envelope_size;
17500 if 6 > max_ordinal {
17501 return Ok(());
17502 }
17503
17504 let cur_offset: usize = (6 - 1) * envelope_size;
17507
17508 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17510
17511 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17516 self.p_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17517 encoder,
17518 offset + cur_offset,
17519 depth,
17520 )?;
17521
17522 _prev_end_offset = cur_offset + envelope_size;
17523
17524 Ok(())
17525 }
17526 }
17527
17528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
17529 for H264QuantizationParameters
17530 {
17531 #[inline(always)]
17532 fn new_empty() -> Self {
17533 Self::default()
17534 }
17535
17536 unsafe fn decode(
17537 &mut self,
17538 decoder: &mut fidl::encoding::Decoder<'_, D>,
17539 offset: usize,
17540 mut depth: fidl::encoding::Depth,
17541 ) -> fidl::Result<()> {
17542 decoder.debug_check_bounds::<Self>(offset);
17543 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17544 None => return Err(fidl::Error::NotNullable),
17545 Some(len) => len,
17546 };
17547 if len == 0 {
17549 return Ok(());
17550 };
17551 depth.increment()?;
17552 let envelope_size = 8;
17553 let bytes_len = len * envelope_size;
17554 let offset = decoder.out_of_line_offset(bytes_len)?;
17555 let mut _next_ordinal_to_read = 0;
17557 let mut next_offset = offset;
17558 let end_offset = offset + bytes_len;
17559 _next_ordinal_to_read += 1;
17560 if next_offset >= end_offset {
17561 return Ok(());
17562 }
17563
17564 while _next_ordinal_to_read < 1 {
17566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17567 _next_ordinal_to_read += 1;
17568 next_offset += envelope_size;
17569 }
17570
17571 let next_out_of_line = decoder.next_out_of_line();
17572 let handles_before = decoder.remaining_handles();
17573 if let Some((inlined, num_bytes, num_handles)) =
17574 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17575 {
17576 let member_inline_size =
17577 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17578 if inlined != (member_inline_size <= 4) {
17579 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17580 }
17581 let inner_offset;
17582 let mut inner_depth = depth.clone();
17583 if inlined {
17584 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17585 inner_offset = next_offset;
17586 } else {
17587 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17588 inner_depth.increment()?;
17589 }
17590 let val_ref = self.i_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17591 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17592 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17593 {
17594 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17595 }
17596 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17597 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17598 }
17599 }
17600
17601 next_offset += envelope_size;
17602 _next_ordinal_to_read += 1;
17603 if next_offset >= end_offset {
17604 return Ok(());
17605 }
17606
17607 while _next_ordinal_to_read < 2 {
17609 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17610 _next_ordinal_to_read += 1;
17611 next_offset += envelope_size;
17612 }
17613
17614 let next_out_of_line = decoder.next_out_of_line();
17615 let handles_before = decoder.remaining_handles();
17616 if let Some((inlined, num_bytes, num_handles)) =
17617 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17618 {
17619 let member_inline_size =
17620 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17621 if inlined != (member_inline_size <= 4) {
17622 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17623 }
17624 let inner_offset;
17625 let mut inner_depth = depth.clone();
17626 if inlined {
17627 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17628 inner_offset = next_offset;
17629 } else {
17630 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17631 inner_depth.increment()?;
17632 }
17633 let val_ref = self.i_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17634 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17635 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17636 {
17637 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17638 }
17639 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17640 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17641 }
17642 }
17643
17644 next_offset += envelope_size;
17645 _next_ordinal_to_read += 1;
17646 if next_offset >= end_offset {
17647 return Ok(());
17648 }
17649
17650 while _next_ordinal_to_read < 3 {
17652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17653 _next_ordinal_to_read += 1;
17654 next_offset += envelope_size;
17655 }
17656
17657 let next_out_of_line = decoder.next_out_of_line();
17658 let handles_before = decoder.remaining_handles();
17659 if let Some((inlined, num_bytes, num_handles)) =
17660 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17661 {
17662 let member_inline_size =
17663 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17664 if inlined != (member_inline_size <= 4) {
17665 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17666 }
17667 let inner_offset;
17668 let mut inner_depth = depth.clone();
17669 if inlined {
17670 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17671 inner_offset = next_offset;
17672 } else {
17673 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17674 inner_depth.increment()?;
17675 }
17676 let val_ref = self.i_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17677 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17678 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17679 {
17680 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17681 }
17682 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17683 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17684 }
17685 }
17686
17687 next_offset += envelope_size;
17688 _next_ordinal_to_read += 1;
17689 if next_offset >= end_offset {
17690 return Ok(());
17691 }
17692
17693 while _next_ordinal_to_read < 4 {
17695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17696 _next_ordinal_to_read += 1;
17697 next_offset += envelope_size;
17698 }
17699
17700 let next_out_of_line = decoder.next_out_of_line();
17701 let handles_before = decoder.remaining_handles();
17702 if let Some((inlined, num_bytes, num_handles)) =
17703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17704 {
17705 let member_inline_size =
17706 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17707 if inlined != (member_inline_size <= 4) {
17708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17709 }
17710 let inner_offset;
17711 let mut inner_depth = depth.clone();
17712 if inlined {
17713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17714 inner_offset = next_offset;
17715 } else {
17716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17717 inner_depth.increment()?;
17718 }
17719 let val_ref = self.p_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17720 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17721 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17722 {
17723 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17724 }
17725 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17726 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17727 }
17728 }
17729
17730 next_offset += envelope_size;
17731 _next_ordinal_to_read += 1;
17732 if next_offset >= end_offset {
17733 return Ok(());
17734 }
17735
17736 while _next_ordinal_to_read < 5 {
17738 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17739 _next_ordinal_to_read += 1;
17740 next_offset += envelope_size;
17741 }
17742
17743 let next_out_of_line = decoder.next_out_of_line();
17744 let handles_before = decoder.remaining_handles();
17745 if let Some((inlined, num_bytes, num_handles)) =
17746 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17747 {
17748 let member_inline_size =
17749 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17750 if inlined != (member_inline_size <= 4) {
17751 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17752 }
17753 let inner_offset;
17754 let mut inner_depth = depth.clone();
17755 if inlined {
17756 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17757 inner_offset = next_offset;
17758 } else {
17759 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17760 inner_depth.increment()?;
17761 }
17762 let val_ref = self.p_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17763 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17764 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17765 {
17766 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17767 }
17768 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17769 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17770 }
17771 }
17772
17773 next_offset += envelope_size;
17774 _next_ordinal_to_read += 1;
17775 if next_offset >= end_offset {
17776 return Ok(());
17777 }
17778
17779 while _next_ordinal_to_read < 6 {
17781 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17782 _next_ordinal_to_read += 1;
17783 next_offset += envelope_size;
17784 }
17785
17786 let next_out_of_line = decoder.next_out_of_line();
17787 let handles_before = decoder.remaining_handles();
17788 if let Some((inlined, num_bytes, num_handles)) =
17789 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17790 {
17791 let member_inline_size =
17792 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17793 if inlined != (member_inline_size <= 4) {
17794 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17795 }
17796 let inner_offset;
17797 let mut inner_depth = depth.clone();
17798 if inlined {
17799 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17800 inner_offset = next_offset;
17801 } else {
17802 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17803 inner_depth.increment()?;
17804 }
17805 let val_ref = self.p_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17806 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17807 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17808 {
17809 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17810 }
17811 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17812 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17813 }
17814 }
17815
17816 next_offset += envelope_size;
17817
17818 while next_offset < end_offset {
17820 _next_ordinal_to_read += 1;
17821 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17822 next_offset += envelope_size;
17823 }
17824
17825 Ok(())
17826 }
17827 }
17828
17829 impl HevcEncoderSettings {
17830 #[inline(always)]
17831 fn max_ordinal_present(&self) -> u64 {
17832 if let Some(_) = self.gop_size {
17833 return 3;
17834 }
17835 if let Some(_) = self.frame_rate {
17836 return 2;
17837 }
17838 if let Some(_) = self.bit_rate {
17839 return 1;
17840 }
17841 0
17842 }
17843 }
17844
17845 impl fidl::encoding::ValueTypeMarker for HevcEncoderSettings {
17846 type Borrowed<'a> = &'a Self;
17847 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17848 value
17849 }
17850 }
17851
17852 unsafe impl fidl::encoding::TypeMarker for HevcEncoderSettings {
17853 type Owned = Self;
17854
17855 #[inline(always)]
17856 fn inline_align(_context: fidl::encoding::Context) -> usize {
17857 8
17858 }
17859
17860 #[inline(always)]
17861 fn inline_size(_context: fidl::encoding::Context) -> usize {
17862 16
17863 }
17864 }
17865
17866 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HevcEncoderSettings, D>
17867 for &HevcEncoderSettings
17868 {
17869 unsafe fn encode(
17870 self,
17871 encoder: &mut fidl::encoding::Encoder<'_, D>,
17872 offset: usize,
17873 mut depth: fidl::encoding::Depth,
17874 ) -> fidl::Result<()> {
17875 encoder.debug_check_bounds::<HevcEncoderSettings>(offset);
17876 let max_ordinal: u64 = self.max_ordinal_present();
17878 encoder.write_num(max_ordinal, offset);
17879 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17880 if max_ordinal == 0 {
17882 return Ok(());
17883 }
17884 depth.increment()?;
17885 let envelope_size = 8;
17886 let bytes_len = max_ordinal as usize * envelope_size;
17887 #[allow(unused_variables)]
17888 let offset = encoder.out_of_line_offset(bytes_len);
17889 let mut _prev_end_offset: usize = 0;
17890 if 1 > max_ordinal {
17891 return Ok(());
17892 }
17893
17894 let cur_offset: usize = (1 - 1) * envelope_size;
17897
17898 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17900
17901 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17906 self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17907 encoder,
17908 offset + cur_offset,
17909 depth,
17910 )?;
17911
17912 _prev_end_offset = cur_offset + envelope_size;
17913 if 2 > max_ordinal {
17914 return Ok(());
17915 }
17916
17917 let cur_offset: usize = (2 - 1) * envelope_size;
17920
17921 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17923
17924 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17929 self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17930 encoder,
17931 offset + cur_offset,
17932 depth,
17933 )?;
17934
17935 _prev_end_offset = cur_offset + envelope_size;
17936 if 3 > max_ordinal {
17937 return Ok(());
17938 }
17939
17940 let cur_offset: usize = (3 - 1) * envelope_size;
17943
17944 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17946
17947 fidl::encoding::encode_in_envelope_optional::<u32, D>(
17952 self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17953 encoder,
17954 offset + cur_offset,
17955 depth,
17956 )?;
17957
17958 _prev_end_offset = cur_offset + envelope_size;
17959
17960 Ok(())
17961 }
17962 }
17963
17964 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HevcEncoderSettings {
17965 #[inline(always)]
17966 fn new_empty() -> Self {
17967 Self::default()
17968 }
17969
17970 unsafe fn decode(
17971 &mut self,
17972 decoder: &mut fidl::encoding::Decoder<'_, D>,
17973 offset: usize,
17974 mut depth: fidl::encoding::Depth,
17975 ) -> fidl::Result<()> {
17976 decoder.debug_check_bounds::<Self>(offset);
17977 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17978 None => return Err(fidl::Error::NotNullable),
17979 Some(len) => len,
17980 };
17981 if len == 0 {
17983 return Ok(());
17984 };
17985 depth.increment()?;
17986 let envelope_size = 8;
17987 let bytes_len = len * envelope_size;
17988 let offset = decoder.out_of_line_offset(bytes_len)?;
17989 let mut _next_ordinal_to_read = 0;
17991 let mut next_offset = offset;
17992 let end_offset = offset + bytes_len;
17993 _next_ordinal_to_read += 1;
17994 if next_offset >= end_offset {
17995 return Ok(());
17996 }
17997
17998 while _next_ordinal_to_read < 1 {
18000 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18001 _next_ordinal_to_read += 1;
18002 next_offset += envelope_size;
18003 }
18004
18005 let next_out_of_line = decoder.next_out_of_line();
18006 let handles_before = decoder.remaining_handles();
18007 if let Some((inlined, num_bytes, num_handles)) =
18008 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18009 {
18010 let member_inline_size =
18011 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18012 if inlined != (member_inline_size <= 4) {
18013 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18014 }
18015 let inner_offset;
18016 let mut inner_depth = depth.clone();
18017 if inlined {
18018 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18019 inner_offset = next_offset;
18020 } else {
18021 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18022 inner_depth.increment()?;
18023 }
18024 let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18025 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18026 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18027 {
18028 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18029 }
18030 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18031 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18032 }
18033 }
18034
18035 next_offset += envelope_size;
18036 _next_ordinal_to_read += 1;
18037 if next_offset >= end_offset {
18038 return Ok(());
18039 }
18040
18041 while _next_ordinal_to_read < 2 {
18043 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18044 _next_ordinal_to_read += 1;
18045 next_offset += envelope_size;
18046 }
18047
18048 let next_out_of_line = decoder.next_out_of_line();
18049 let handles_before = decoder.remaining_handles();
18050 if let Some((inlined, num_bytes, num_handles)) =
18051 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18052 {
18053 let member_inline_size =
18054 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18055 if inlined != (member_inline_size <= 4) {
18056 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18057 }
18058 let inner_offset;
18059 let mut inner_depth = depth.clone();
18060 if inlined {
18061 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18062 inner_offset = next_offset;
18063 } else {
18064 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18065 inner_depth.increment()?;
18066 }
18067 let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18068 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18069 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18070 {
18071 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18072 }
18073 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18074 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18075 }
18076 }
18077
18078 next_offset += envelope_size;
18079 _next_ordinal_to_read += 1;
18080 if next_offset >= end_offset {
18081 return Ok(());
18082 }
18083
18084 while _next_ordinal_to_read < 3 {
18086 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18087 _next_ordinal_to_read += 1;
18088 next_offset += envelope_size;
18089 }
18090
18091 let next_out_of_line = decoder.next_out_of_line();
18092 let handles_before = decoder.remaining_handles();
18093 if let Some((inlined, num_bytes, num_handles)) =
18094 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18095 {
18096 let member_inline_size =
18097 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18098 if inlined != (member_inline_size <= 4) {
18099 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18100 }
18101 let inner_offset;
18102 let mut inner_depth = depth.clone();
18103 if inlined {
18104 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18105 inner_offset = next_offset;
18106 } else {
18107 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18108 inner_depth.increment()?;
18109 }
18110 let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
18111 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18112 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18113 {
18114 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18115 }
18116 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18117 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18118 }
18119 }
18120
18121 next_offset += envelope_size;
18122
18123 while next_offset < end_offset {
18125 _next_ordinal_to_read += 1;
18126 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18127 next_offset += envelope_size;
18128 }
18129
18130 Ok(())
18131 }
18132 }
18133
18134 impl InputAudioCapturerConfiguration {
18135 #[inline(always)]
18136 fn max_ordinal_present(&self) -> u64 {
18137 if let Some(_) = self.usage2 {
18138 return 2;
18139 }
18140 if let Some(_) = self.usage {
18141 return 1;
18142 }
18143 0
18144 }
18145 }
18146
18147 impl fidl::encoding::ValueTypeMarker for InputAudioCapturerConfiguration {
18148 type Borrowed<'a> = &'a Self;
18149 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18150 value
18151 }
18152 }
18153
18154 unsafe impl fidl::encoding::TypeMarker for InputAudioCapturerConfiguration {
18155 type Owned = Self;
18156
18157 #[inline(always)]
18158 fn inline_align(_context: fidl::encoding::Context) -> usize {
18159 8
18160 }
18161
18162 #[inline(always)]
18163 fn inline_size(_context: fidl::encoding::Context) -> usize {
18164 16
18165 }
18166 }
18167
18168 unsafe impl<D: fidl::encoding::ResourceDialect>
18169 fidl::encoding::Encode<InputAudioCapturerConfiguration, D>
18170 for &InputAudioCapturerConfiguration
18171 {
18172 unsafe fn encode(
18173 self,
18174 encoder: &mut fidl::encoding::Encoder<'_, D>,
18175 offset: usize,
18176 mut depth: fidl::encoding::Depth,
18177 ) -> fidl::Result<()> {
18178 encoder.debug_check_bounds::<InputAudioCapturerConfiguration>(offset);
18179 let max_ordinal: u64 = self.max_ordinal_present();
18181 encoder.write_num(max_ordinal, offset);
18182 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18183 if max_ordinal == 0 {
18185 return Ok(());
18186 }
18187 depth.increment()?;
18188 let envelope_size = 8;
18189 let bytes_len = max_ordinal as usize * envelope_size;
18190 #[allow(unused_variables)]
18191 let offset = encoder.out_of_line_offset(bytes_len);
18192 let mut _prev_end_offset: usize = 0;
18193 if 1 > max_ordinal {
18194 return Ok(());
18195 }
18196
18197 let cur_offset: usize = (1 - 1) * envelope_size;
18200
18201 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18203
18204 fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage, D>(
18209 self.usage
18210 .as_ref()
18211 .map(<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow),
18212 encoder,
18213 offset + cur_offset,
18214 depth,
18215 )?;
18216
18217 _prev_end_offset = cur_offset + envelope_size;
18218 if 2 > max_ordinal {
18219 return Ok(());
18220 }
18221
18222 let cur_offset: usize = (2 - 1) * envelope_size;
18225
18226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18228
18229 fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage2, D>(
18234 self.usage2
18235 .as_ref()
18236 .map(<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow),
18237 encoder,
18238 offset + cur_offset,
18239 depth,
18240 )?;
18241
18242 _prev_end_offset = cur_offset + envelope_size;
18243
18244 Ok(())
18245 }
18246 }
18247
18248 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18249 for InputAudioCapturerConfiguration
18250 {
18251 #[inline(always)]
18252 fn new_empty() -> Self {
18253 Self::default()
18254 }
18255
18256 unsafe fn decode(
18257 &mut self,
18258 decoder: &mut fidl::encoding::Decoder<'_, D>,
18259 offset: usize,
18260 mut depth: fidl::encoding::Depth,
18261 ) -> fidl::Result<()> {
18262 decoder.debug_check_bounds::<Self>(offset);
18263 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18264 None => return Err(fidl::Error::NotNullable),
18265 Some(len) => len,
18266 };
18267 if len == 0 {
18269 return Ok(());
18270 };
18271 depth.increment()?;
18272 let envelope_size = 8;
18273 let bytes_len = len * envelope_size;
18274 let offset = decoder.out_of_line_offset(bytes_len)?;
18275 let mut _next_ordinal_to_read = 0;
18277 let mut next_offset = offset;
18278 let end_offset = offset + bytes_len;
18279 _next_ordinal_to_read += 1;
18280 if next_offset >= end_offset {
18281 return Ok(());
18282 }
18283
18284 while _next_ordinal_to_read < 1 {
18286 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18287 _next_ordinal_to_read += 1;
18288 next_offset += envelope_size;
18289 }
18290
18291 let next_out_of_line = decoder.next_out_of_line();
18292 let handles_before = decoder.remaining_handles();
18293 if let Some((inlined, num_bytes, num_handles)) =
18294 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18295 {
18296 let member_inline_size =
18297 <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18298 if inlined != (member_inline_size <= 4) {
18299 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18300 }
18301 let inner_offset;
18302 let mut inner_depth = depth.clone();
18303 if inlined {
18304 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18305 inner_offset = next_offset;
18306 } else {
18307 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18308 inner_depth.increment()?;
18309 }
18310 let val_ref =
18311 self.usage.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage, D));
18312 fidl::decode!(AudioCaptureUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
18313 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18314 {
18315 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18316 }
18317 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18318 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18319 }
18320 }
18321
18322 next_offset += envelope_size;
18323 _next_ordinal_to_read += 1;
18324 if next_offset >= end_offset {
18325 return Ok(());
18326 }
18327
18328 while _next_ordinal_to_read < 2 {
18330 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18331 _next_ordinal_to_read += 1;
18332 next_offset += envelope_size;
18333 }
18334
18335 let next_out_of_line = decoder.next_out_of_line();
18336 let handles_before = decoder.remaining_handles();
18337 if let Some((inlined, num_bytes, num_handles)) =
18338 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18339 {
18340 let member_inline_size =
18341 <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(
18342 decoder.context,
18343 );
18344 if inlined != (member_inline_size <= 4) {
18345 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18346 }
18347 let inner_offset;
18348 let mut inner_depth = depth.clone();
18349 if inlined {
18350 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18351 inner_offset = next_offset;
18352 } else {
18353 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18354 inner_depth.increment()?;
18355 }
18356 let val_ref =
18357 self.usage2.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage2, D));
18358 fidl::decode!(AudioCaptureUsage2, D, val_ref, decoder, inner_offset, inner_depth)?;
18359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18360 {
18361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18362 }
18363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18365 }
18366 }
18367
18368 next_offset += envelope_size;
18369
18370 while next_offset < end_offset {
18372 _next_ordinal_to_read += 1;
18373 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18374 next_offset += envelope_size;
18375 }
18376
18377 Ok(())
18378 }
18379 }
18380
18381 impl Lc3EncoderSettings {
18382 #[inline(always)]
18383 fn max_ordinal_present(&self) -> u64 {
18384 if let Some(_) = self.frame_duration {
18385 return 2;
18386 }
18387 if let Some(_) = self.nbytes {
18388 return 1;
18389 }
18390 0
18391 }
18392 }
18393
18394 impl fidl::encoding::ValueTypeMarker for Lc3EncoderSettings {
18395 type Borrowed<'a> = &'a Self;
18396 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18397 value
18398 }
18399 }
18400
18401 unsafe impl fidl::encoding::TypeMarker for Lc3EncoderSettings {
18402 type Owned = Self;
18403
18404 #[inline(always)]
18405 fn inline_align(_context: fidl::encoding::Context) -> usize {
18406 8
18407 }
18408
18409 #[inline(always)]
18410 fn inline_size(_context: fidl::encoding::Context) -> usize {
18411 16
18412 }
18413 }
18414
18415 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Lc3EncoderSettings, D>
18416 for &Lc3EncoderSettings
18417 {
18418 unsafe fn encode(
18419 self,
18420 encoder: &mut fidl::encoding::Encoder<'_, D>,
18421 offset: usize,
18422 mut depth: fidl::encoding::Depth,
18423 ) -> fidl::Result<()> {
18424 encoder.debug_check_bounds::<Lc3EncoderSettings>(offset);
18425 let max_ordinal: u64 = self.max_ordinal_present();
18427 encoder.write_num(max_ordinal, offset);
18428 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18429 if max_ordinal == 0 {
18431 return Ok(());
18432 }
18433 depth.increment()?;
18434 let envelope_size = 8;
18435 let bytes_len = max_ordinal as usize * envelope_size;
18436 #[allow(unused_variables)]
18437 let offset = encoder.out_of_line_offset(bytes_len);
18438 let mut _prev_end_offset: usize = 0;
18439 if 1 > max_ordinal {
18440 return Ok(());
18441 }
18442
18443 let cur_offset: usize = (1 - 1) * envelope_size;
18446
18447 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18449
18450 fidl::encoding::encode_in_envelope_optional::<u16, D>(
18455 self.nbytes.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
18456 encoder,
18457 offset + cur_offset,
18458 depth,
18459 )?;
18460
18461 _prev_end_offset = cur_offset + envelope_size;
18462 if 2 > max_ordinal {
18463 return Ok(());
18464 }
18465
18466 let cur_offset: usize = (2 - 1) * envelope_size;
18469
18470 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18472
18473 fidl::encoding::encode_in_envelope_optional::<Lc3FrameDuration, D>(
18478 self.frame_duration
18479 .as_ref()
18480 .map(<Lc3FrameDuration as fidl::encoding::ValueTypeMarker>::borrow),
18481 encoder,
18482 offset + cur_offset,
18483 depth,
18484 )?;
18485
18486 _prev_end_offset = cur_offset + envelope_size;
18487
18488 Ok(())
18489 }
18490 }
18491
18492 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3EncoderSettings {
18493 #[inline(always)]
18494 fn new_empty() -> Self {
18495 Self::default()
18496 }
18497
18498 unsafe fn decode(
18499 &mut self,
18500 decoder: &mut fidl::encoding::Decoder<'_, D>,
18501 offset: usize,
18502 mut depth: fidl::encoding::Depth,
18503 ) -> fidl::Result<()> {
18504 decoder.debug_check_bounds::<Self>(offset);
18505 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18506 None => return Err(fidl::Error::NotNullable),
18507 Some(len) => len,
18508 };
18509 if len == 0 {
18511 return Ok(());
18512 };
18513 depth.increment()?;
18514 let envelope_size = 8;
18515 let bytes_len = len * envelope_size;
18516 let offset = decoder.out_of_line_offset(bytes_len)?;
18517 let mut _next_ordinal_to_read = 0;
18519 let mut next_offset = offset;
18520 let end_offset = offset + bytes_len;
18521 _next_ordinal_to_read += 1;
18522 if next_offset >= end_offset {
18523 return Ok(());
18524 }
18525
18526 while _next_ordinal_to_read < 1 {
18528 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18529 _next_ordinal_to_read += 1;
18530 next_offset += envelope_size;
18531 }
18532
18533 let next_out_of_line = decoder.next_out_of_line();
18534 let handles_before = decoder.remaining_handles();
18535 if let Some((inlined, num_bytes, num_handles)) =
18536 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18537 {
18538 let member_inline_size =
18539 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18540 if inlined != (member_inline_size <= 4) {
18541 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18542 }
18543 let inner_offset;
18544 let mut inner_depth = depth.clone();
18545 if inlined {
18546 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18547 inner_offset = next_offset;
18548 } else {
18549 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18550 inner_depth.increment()?;
18551 }
18552 let val_ref = self.nbytes.get_or_insert_with(|| fidl::new_empty!(u16, D));
18553 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
18554 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18555 {
18556 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18557 }
18558 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18559 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18560 }
18561 }
18562
18563 next_offset += envelope_size;
18564 _next_ordinal_to_read += 1;
18565 if next_offset >= end_offset {
18566 return Ok(());
18567 }
18568
18569 while _next_ordinal_to_read < 2 {
18571 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18572 _next_ordinal_to_read += 1;
18573 next_offset += envelope_size;
18574 }
18575
18576 let next_out_of_line = decoder.next_out_of_line();
18577 let handles_before = decoder.remaining_handles();
18578 if let Some((inlined, num_bytes, num_handles)) =
18579 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18580 {
18581 let member_inline_size =
18582 <Lc3FrameDuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18583 if inlined != (member_inline_size <= 4) {
18584 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18585 }
18586 let inner_offset;
18587 let mut inner_depth = depth.clone();
18588 if inlined {
18589 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18590 inner_offset = next_offset;
18591 } else {
18592 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18593 inner_depth.increment()?;
18594 }
18595 let val_ref = self
18596 .frame_duration
18597 .get_or_insert_with(|| fidl::new_empty!(Lc3FrameDuration, D));
18598 fidl::decode!(Lc3FrameDuration, D, val_ref, decoder, inner_offset, inner_depth)?;
18599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18600 {
18601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18602 }
18603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18605 }
18606 }
18607
18608 next_offset += envelope_size;
18609
18610 while next_offset < end_offset {
18612 _next_ordinal_to_read += 1;
18613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18614 next_offset += envelope_size;
18615 }
18616
18617 Ok(())
18618 }
18619 }
18620
18621 impl LoopbackAudioCapturerConfiguration {
18622 #[inline(always)]
18623 fn max_ordinal_present(&self) -> u64 {
18624 0
18625 }
18626 }
18627
18628 impl fidl::encoding::ValueTypeMarker for LoopbackAudioCapturerConfiguration {
18629 type Borrowed<'a> = &'a Self;
18630 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18631 value
18632 }
18633 }
18634
18635 unsafe impl fidl::encoding::TypeMarker for LoopbackAudioCapturerConfiguration {
18636 type Owned = Self;
18637
18638 #[inline(always)]
18639 fn inline_align(_context: fidl::encoding::Context) -> usize {
18640 8
18641 }
18642
18643 #[inline(always)]
18644 fn inline_size(_context: fidl::encoding::Context) -> usize {
18645 16
18646 }
18647 }
18648
18649 unsafe impl<D: fidl::encoding::ResourceDialect>
18650 fidl::encoding::Encode<LoopbackAudioCapturerConfiguration, D>
18651 for &LoopbackAudioCapturerConfiguration
18652 {
18653 unsafe fn encode(
18654 self,
18655 encoder: &mut fidl::encoding::Encoder<'_, D>,
18656 offset: usize,
18657 mut depth: fidl::encoding::Depth,
18658 ) -> fidl::Result<()> {
18659 encoder.debug_check_bounds::<LoopbackAudioCapturerConfiguration>(offset);
18660 let max_ordinal: u64 = self.max_ordinal_present();
18662 encoder.write_num(max_ordinal, offset);
18663 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18664 if max_ordinal == 0 {
18666 return Ok(());
18667 }
18668 depth.increment()?;
18669 let envelope_size = 8;
18670 let bytes_len = max_ordinal as usize * envelope_size;
18671 #[allow(unused_variables)]
18672 let offset = encoder.out_of_line_offset(bytes_len);
18673 let mut _prev_end_offset: usize = 0;
18674
18675 Ok(())
18676 }
18677 }
18678
18679 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18680 for LoopbackAudioCapturerConfiguration
18681 {
18682 #[inline(always)]
18683 fn new_empty() -> Self {
18684 Self::default()
18685 }
18686
18687 unsafe fn decode(
18688 &mut self,
18689 decoder: &mut fidl::encoding::Decoder<'_, D>,
18690 offset: usize,
18691 mut depth: fidl::encoding::Depth,
18692 ) -> fidl::Result<()> {
18693 decoder.debug_check_bounds::<Self>(offset);
18694 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18695 None => return Err(fidl::Error::NotNullable),
18696 Some(len) => len,
18697 };
18698 if len == 0 {
18700 return Ok(());
18701 };
18702 depth.increment()?;
18703 let envelope_size = 8;
18704 let bytes_len = len * envelope_size;
18705 let offset = decoder.out_of_line_offset(bytes_len)?;
18706 let mut _next_ordinal_to_read = 0;
18708 let mut next_offset = offset;
18709 let end_offset = offset + bytes_len;
18710
18711 while next_offset < end_offset {
18713 _next_ordinal_to_read += 1;
18714 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18715 next_offset += envelope_size;
18716 }
18717
18718 Ok(())
18719 }
18720 }
18721
18722 impl MSbcEncoderSettings {
18723 #[inline(always)]
18724 fn max_ordinal_present(&self) -> u64 {
18725 0
18726 }
18727 }
18728
18729 impl fidl::encoding::ValueTypeMarker for MSbcEncoderSettings {
18730 type Borrowed<'a> = &'a Self;
18731 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18732 value
18733 }
18734 }
18735
18736 unsafe impl fidl::encoding::TypeMarker for MSbcEncoderSettings {
18737 type Owned = Self;
18738
18739 #[inline(always)]
18740 fn inline_align(_context: fidl::encoding::Context) -> usize {
18741 8
18742 }
18743
18744 #[inline(always)]
18745 fn inline_size(_context: fidl::encoding::Context) -> usize {
18746 16
18747 }
18748 }
18749
18750 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MSbcEncoderSettings, D>
18751 for &MSbcEncoderSettings
18752 {
18753 unsafe fn encode(
18754 self,
18755 encoder: &mut fidl::encoding::Encoder<'_, D>,
18756 offset: usize,
18757 mut depth: fidl::encoding::Depth,
18758 ) -> fidl::Result<()> {
18759 encoder.debug_check_bounds::<MSbcEncoderSettings>(offset);
18760 let max_ordinal: u64 = self.max_ordinal_present();
18762 encoder.write_num(max_ordinal, offset);
18763 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18764 if max_ordinal == 0 {
18766 return Ok(());
18767 }
18768 depth.increment()?;
18769 let envelope_size = 8;
18770 let bytes_len = max_ordinal as usize * envelope_size;
18771 #[allow(unused_variables)]
18772 let offset = encoder.out_of_line_offset(bytes_len);
18773 let mut _prev_end_offset: usize = 0;
18774
18775 Ok(())
18776 }
18777 }
18778
18779 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MSbcEncoderSettings {
18780 #[inline(always)]
18781 fn new_empty() -> Self {
18782 Self::default()
18783 }
18784
18785 unsafe fn decode(
18786 &mut self,
18787 decoder: &mut fidl::encoding::Decoder<'_, D>,
18788 offset: usize,
18789 mut depth: fidl::encoding::Depth,
18790 ) -> fidl::Result<()> {
18791 decoder.debug_check_bounds::<Self>(offset);
18792 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18793 None => return Err(fidl::Error::NotNullable),
18794 Some(len) => len,
18795 };
18796 if len == 0 {
18798 return Ok(());
18799 };
18800 depth.increment()?;
18801 let envelope_size = 8;
18802 let bytes_len = len * envelope_size;
18803 let offset = decoder.out_of_line_offset(bytes_len)?;
18804 let mut _next_ordinal_to_read = 0;
18806 let mut next_offset = offset;
18807 let end_offset = offset + bytes_len;
18808
18809 while next_offset < end_offset {
18811 _next_ordinal_to_read += 1;
18812 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18813 next_offset += envelope_size;
18814 }
18815
18816 Ok(())
18817 }
18818 }
18819
18820 impl Packet {
18821 #[inline(always)]
18822 fn max_ordinal_present(&self) -> u64 {
18823 if let Some(_) = self.key_frame {
18824 return 9;
18825 }
18826 if let Some(_) = self.known_end_access_unit {
18827 return 8;
18828 }
18829 if let Some(_) = self.start_access_unit {
18830 return 7;
18831 }
18832 if let Some(_) = self.timestamp_ish {
18833 return 6;
18834 }
18835 if let Some(_) = self.valid_length_bytes {
18836 return 5;
18837 }
18838 if let Some(_) = self.start_offset {
18839 return 4;
18840 }
18841 if let Some(_) = self.stream_lifetime_ordinal {
18842 return 3;
18843 }
18844 if let Some(_) = self.buffer_index {
18845 return 2;
18846 }
18847 if let Some(_) = self.header {
18848 return 1;
18849 }
18850 0
18851 }
18852 }
18853
18854 impl fidl::encoding::ValueTypeMarker for Packet {
18855 type Borrowed<'a> = &'a Self;
18856 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18857 value
18858 }
18859 }
18860
18861 unsafe impl fidl::encoding::TypeMarker for Packet {
18862 type Owned = Self;
18863
18864 #[inline(always)]
18865 fn inline_align(_context: fidl::encoding::Context) -> usize {
18866 8
18867 }
18868
18869 #[inline(always)]
18870 fn inline_size(_context: fidl::encoding::Context) -> usize {
18871 16
18872 }
18873 }
18874
18875 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Packet, D> for &Packet {
18876 unsafe fn encode(
18877 self,
18878 encoder: &mut fidl::encoding::Encoder<'_, D>,
18879 offset: usize,
18880 mut depth: fidl::encoding::Depth,
18881 ) -> fidl::Result<()> {
18882 encoder.debug_check_bounds::<Packet>(offset);
18883 let max_ordinal: u64 = self.max_ordinal_present();
18885 encoder.write_num(max_ordinal, offset);
18886 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18887 if max_ordinal == 0 {
18889 return Ok(());
18890 }
18891 depth.increment()?;
18892 let envelope_size = 8;
18893 let bytes_len = max_ordinal as usize * envelope_size;
18894 #[allow(unused_variables)]
18895 let offset = encoder.out_of_line_offset(bytes_len);
18896 let mut _prev_end_offset: usize = 0;
18897 if 1 > max_ordinal {
18898 return Ok(());
18899 }
18900
18901 let cur_offset: usize = (1 - 1) * envelope_size;
18904
18905 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18907
18908 fidl::encoding::encode_in_envelope_optional::<PacketHeader, D>(
18913 self.header.as_ref().map(<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow),
18914 encoder,
18915 offset + cur_offset,
18916 depth,
18917 )?;
18918
18919 _prev_end_offset = cur_offset + envelope_size;
18920 if 2 > max_ordinal {
18921 return Ok(());
18922 }
18923
18924 let cur_offset: usize = (2 - 1) * envelope_size;
18927
18928 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18930
18931 fidl::encoding::encode_in_envelope_optional::<u32, D>(
18936 self.buffer_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18937 encoder,
18938 offset + cur_offset,
18939 depth,
18940 )?;
18941
18942 _prev_end_offset = cur_offset + envelope_size;
18943 if 3 > max_ordinal {
18944 return Ok(());
18945 }
18946
18947 let cur_offset: usize = (3 - 1) * envelope_size;
18950
18951 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18953
18954 fidl::encoding::encode_in_envelope_optional::<u64, D>(
18959 self.stream_lifetime_ordinal
18960 .as_ref()
18961 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
18962 encoder,
18963 offset + cur_offset,
18964 depth,
18965 )?;
18966
18967 _prev_end_offset = cur_offset + envelope_size;
18968 if 4 > max_ordinal {
18969 return Ok(());
18970 }
18971
18972 let cur_offset: usize = (4 - 1) * envelope_size;
18975
18976 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18978
18979 fidl::encoding::encode_in_envelope_optional::<u32, D>(
18984 self.start_offset.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18985 encoder,
18986 offset + cur_offset,
18987 depth,
18988 )?;
18989
18990 _prev_end_offset = cur_offset + envelope_size;
18991 if 5 > max_ordinal {
18992 return Ok(());
18993 }
18994
18995 let cur_offset: usize = (5 - 1) * envelope_size;
18998
18999 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19001
19002 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19007 self.valid_length_bytes
19008 .as_ref()
19009 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19010 encoder,
19011 offset + cur_offset,
19012 depth,
19013 )?;
19014
19015 _prev_end_offset = cur_offset + envelope_size;
19016 if 6 > max_ordinal {
19017 return Ok(());
19018 }
19019
19020 let cur_offset: usize = (6 - 1) * envelope_size;
19023
19024 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19026
19027 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19032 self.timestamp_ish.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19033 encoder,
19034 offset + cur_offset,
19035 depth,
19036 )?;
19037
19038 _prev_end_offset = cur_offset + envelope_size;
19039 if 7 > max_ordinal {
19040 return Ok(());
19041 }
19042
19043 let cur_offset: usize = (7 - 1) * envelope_size;
19046
19047 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19049
19050 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19055 self.start_access_unit
19056 .as_ref()
19057 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19058 encoder,
19059 offset + cur_offset,
19060 depth,
19061 )?;
19062
19063 _prev_end_offset = cur_offset + envelope_size;
19064 if 8 > max_ordinal {
19065 return Ok(());
19066 }
19067
19068 let cur_offset: usize = (8 - 1) * envelope_size;
19071
19072 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19074
19075 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19080 self.known_end_access_unit
19081 .as_ref()
19082 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19083 encoder,
19084 offset + cur_offset,
19085 depth,
19086 )?;
19087
19088 _prev_end_offset = cur_offset + envelope_size;
19089 if 9 > max_ordinal {
19090 return Ok(());
19091 }
19092
19093 let cur_offset: usize = (9 - 1) * envelope_size;
19096
19097 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19099
19100 fidl::encoding::encode_in_envelope_optional::<bool, D>(
19105 self.key_frame.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19106 encoder,
19107 offset + cur_offset,
19108 depth,
19109 )?;
19110
19111 _prev_end_offset = cur_offset + envelope_size;
19112
19113 Ok(())
19114 }
19115 }
19116
19117 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Packet {
19118 #[inline(always)]
19119 fn new_empty() -> Self {
19120 Self::default()
19121 }
19122
19123 unsafe fn decode(
19124 &mut self,
19125 decoder: &mut fidl::encoding::Decoder<'_, D>,
19126 offset: usize,
19127 mut depth: fidl::encoding::Depth,
19128 ) -> fidl::Result<()> {
19129 decoder.debug_check_bounds::<Self>(offset);
19130 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19131 None => return Err(fidl::Error::NotNullable),
19132 Some(len) => len,
19133 };
19134 if len == 0 {
19136 return Ok(());
19137 };
19138 depth.increment()?;
19139 let envelope_size = 8;
19140 let bytes_len = len * envelope_size;
19141 let offset = decoder.out_of_line_offset(bytes_len)?;
19142 let mut _next_ordinal_to_read = 0;
19144 let mut next_offset = offset;
19145 let end_offset = offset + bytes_len;
19146 _next_ordinal_to_read += 1;
19147 if next_offset >= end_offset {
19148 return Ok(());
19149 }
19150
19151 while _next_ordinal_to_read < 1 {
19153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19154 _next_ordinal_to_read += 1;
19155 next_offset += envelope_size;
19156 }
19157
19158 let next_out_of_line = decoder.next_out_of_line();
19159 let handles_before = decoder.remaining_handles();
19160 if let Some((inlined, num_bytes, num_handles)) =
19161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19162 {
19163 let member_inline_size =
19164 <PacketHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19165 if inlined != (member_inline_size <= 4) {
19166 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19167 }
19168 let inner_offset;
19169 let mut inner_depth = depth.clone();
19170 if inlined {
19171 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19172 inner_offset = next_offset;
19173 } else {
19174 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19175 inner_depth.increment()?;
19176 }
19177 let val_ref = self.header.get_or_insert_with(|| fidl::new_empty!(PacketHeader, D));
19178 fidl::decode!(PacketHeader, D, val_ref, decoder, inner_offset, inner_depth)?;
19179 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19180 {
19181 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19182 }
19183 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19184 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19185 }
19186 }
19187
19188 next_offset += envelope_size;
19189 _next_ordinal_to_read += 1;
19190 if next_offset >= end_offset {
19191 return Ok(());
19192 }
19193
19194 while _next_ordinal_to_read < 2 {
19196 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19197 _next_ordinal_to_read += 1;
19198 next_offset += envelope_size;
19199 }
19200
19201 let next_out_of_line = decoder.next_out_of_line();
19202 let handles_before = decoder.remaining_handles();
19203 if let Some((inlined, num_bytes, num_handles)) =
19204 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19205 {
19206 let member_inline_size =
19207 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19208 if inlined != (member_inline_size <= 4) {
19209 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19210 }
19211 let inner_offset;
19212 let mut inner_depth = depth.clone();
19213 if inlined {
19214 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19215 inner_offset = next_offset;
19216 } else {
19217 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19218 inner_depth.increment()?;
19219 }
19220 let val_ref = self.buffer_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19221 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19222 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19223 {
19224 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19225 }
19226 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19227 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19228 }
19229 }
19230
19231 next_offset += envelope_size;
19232 _next_ordinal_to_read += 1;
19233 if next_offset >= end_offset {
19234 return Ok(());
19235 }
19236
19237 while _next_ordinal_to_read < 3 {
19239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19240 _next_ordinal_to_read += 1;
19241 next_offset += envelope_size;
19242 }
19243
19244 let next_out_of_line = decoder.next_out_of_line();
19245 let handles_before = decoder.remaining_handles();
19246 if let Some((inlined, num_bytes, num_handles)) =
19247 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19248 {
19249 let member_inline_size =
19250 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19251 if inlined != (member_inline_size <= 4) {
19252 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19253 }
19254 let inner_offset;
19255 let mut inner_depth = depth.clone();
19256 if inlined {
19257 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19258 inner_offset = next_offset;
19259 } else {
19260 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19261 inner_depth.increment()?;
19262 }
19263 let val_ref =
19264 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19265 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19266 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19267 {
19268 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19269 }
19270 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19271 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19272 }
19273 }
19274
19275 next_offset += envelope_size;
19276 _next_ordinal_to_read += 1;
19277 if next_offset >= end_offset {
19278 return Ok(());
19279 }
19280
19281 while _next_ordinal_to_read < 4 {
19283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19284 _next_ordinal_to_read += 1;
19285 next_offset += envelope_size;
19286 }
19287
19288 let next_out_of_line = decoder.next_out_of_line();
19289 let handles_before = decoder.remaining_handles();
19290 if let Some((inlined, num_bytes, num_handles)) =
19291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19292 {
19293 let member_inline_size =
19294 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19295 if inlined != (member_inline_size <= 4) {
19296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19297 }
19298 let inner_offset;
19299 let mut inner_depth = depth.clone();
19300 if inlined {
19301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19302 inner_offset = next_offset;
19303 } else {
19304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19305 inner_depth.increment()?;
19306 }
19307 let val_ref = self.start_offset.get_or_insert_with(|| fidl::new_empty!(u32, D));
19308 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19309 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19310 {
19311 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19312 }
19313 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19314 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19315 }
19316 }
19317
19318 next_offset += envelope_size;
19319 _next_ordinal_to_read += 1;
19320 if next_offset >= end_offset {
19321 return Ok(());
19322 }
19323
19324 while _next_ordinal_to_read < 5 {
19326 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19327 _next_ordinal_to_read += 1;
19328 next_offset += envelope_size;
19329 }
19330
19331 let next_out_of_line = decoder.next_out_of_line();
19332 let handles_before = decoder.remaining_handles();
19333 if let Some((inlined, num_bytes, num_handles)) =
19334 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19335 {
19336 let member_inline_size =
19337 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19338 if inlined != (member_inline_size <= 4) {
19339 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19340 }
19341 let inner_offset;
19342 let mut inner_depth = depth.clone();
19343 if inlined {
19344 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19345 inner_offset = next_offset;
19346 } else {
19347 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19348 inner_depth.increment()?;
19349 }
19350 let val_ref =
19351 self.valid_length_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
19352 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19353 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19354 {
19355 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19356 }
19357 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19358 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19359 }
19360 }
19361
19362 next_offset += envelope_size;
19363 _next_ordinal_to_read += 1;
19364 if next_offset >= end_offset {
19365 return Ok(());
19366 }
19367
19368 while _next_ordinal_to_read < 6 {
19370 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19371 _next_ordinal_to_read += 1;
19372 next_offset += envelope_size;
19373 }
19374
19375 let next_out_of_line = decoder.next_out_of_line();
19376 let handles_before = decoder.remaining_handles();
19377 if let Some((inlined, num_bytes, num_handles)) =
19378 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19379 {
19380 let member_inline_size =
19381 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19382 if inlined != (member_inline_size <= 4) {
19383 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19384 }
19385 let inner_offset;
19386 let mut inner_depth = depth.clone();
19387 if inlined {
19388 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19389 inner_offset = next_offset;
19390 } else {
19391 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19392 inner_depth.increment()?;
19393 }
19394 let val_ref = self.timestamp_ish.get_or_insert_with(|| fidl::new_empty!(u64, D));
19395 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19396 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19397 {
19398 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19399 }
19400 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19401 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19402 }
19403 }
19404
19405 next_offset += envelope_size;
19406 _next_ordinal_to_read += 1;
19407 if next_offset >= end_offset {
19408 return Ok(());
19409 }
19410
19411 while _next_ordinal_to_read < 7 {
19413 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19414 _next_ordinal_to_read += 1;
19415 next_offset += envelope_size;
19416 }
19417
19418 let next_out_of_line = decoder.next_out_of_line();
19419 let handles_before = decoder.remaining_handles();
19420 if let Some((inlined, num_bytes, num_handles)) =
19421 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19422 {
19423 let member_inline_size =
19424 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19425 if inlined != (member_inline_size <= 4) {
19426 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19427 }
19428 let inner_offset;
19429 let mut inner_depth = depth.clone();
19430 if inlined {
19431 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19432 inner_offset = next_offset;
19433 } else {
19434 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19435 inner_depth.increment()?;
19436 }
19437 let val_ref =
19438 self.start_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19439 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19441 {
19442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19443 }
19444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19446 }
19447 }
19448
19449 next_offset += envelope_size;
19450 _next_ordinal_to_read += 1;
19451 if next_offset >= end_offset {
19452 return Ok(());
19453 }
19454
19455 while _next_ordinal_to_read < 8 {
19457 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19458 _next_ordinal_to_read += 1;
19459 next_offset += envelope_size;
19460 }
19461
19462 let next_out_of_line = decoder.next_out_of_line();
19463 let handles_before = decoder.remaining_handles();
19464 if let Some((inlined, num_bytes, num_handles)) =
19465 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19466 {
19467 let member_inline_size =
19468 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19469 if inlined != (member_inline_size <= 4) {
19470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19471 }
19472 let inner_offset;
19473 let mut inner_depth = depth.clone();
19474 if inlined {
19475 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19476 inner_offset = next_offset;
19477 } else {
19478 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19479 inner_depth.increment()?;
19480 }
19481 let val_ref =
19482 self.known_end_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19483 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19484 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19485 {
19486 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19487 }
19488 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19489 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19490 }
19491 }
19492
19493 next_offset += envelope_size;
19494 _next_ordinal_to_read += 1;
19495 if next_offset >= end_offset {
19496 return Ok(());
19497 }
19498
19499 while _next_ordinal_to_read < 9 {
19501 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19502 _next_ordinal_to_read += 1;
19503 next_offset += envelope_size;
19504 }
19505
19506 let next_out_of_line = decoder.next_out_of_line();
19507 let handles_before = decoder.remaining_handles();
19508 if let Some((inlined, num_bytes, num_handles)) =
19509 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19510 {
19511 let member_inline_size =
19512 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19513 if inlined != (member_inline_size <= 4) {
19514 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19515 }
19516 let inner_offset;
19517 let mut inner_depth = depth.clone();
19518 if inlined {
19519 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19520 inner_offset = next_offset;
19521 } else {
19522 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19523 inner_depth.increment()?;
19524 }
19525 let val_ref = self.key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
19526 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19527 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19528 {
19529 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19530 }
19531 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19532 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19533 }
19534 }
19535
19536 next_offset += envelope_size;
19537
19538 while next_offset < end_offset {
19540 _next_ordinal_to_read += 1;
19541 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19542 next_offset += envelope_size;
19543 }
19544
19545 Ok(())
19546 }
19547 }
19548
19549 impl PacketHeader {
19550 #[inline(always)]
19551 fn max_ordinal_present(&self) -> u64 {
19552 if let Some(_) = self.packet_index {
19553 return 2;
19554 }
19555 if let Some(_) = self.buffer_lifetime_ordinal {
19556 return 1;
19557 }
19558 0
19559 }
19560 }
19561
19562 impl fidl::encoding::ValueTypeMarker for PacketHeader {
19563 type Borrowed<'a> = &'a Self;
19564 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19565 value
19566 }
19567 }
19568
19569 unsafe impl fidl::encoding::TypeMarker for PacketHeader {
19570 type Owned = Self;
19571
19572 #[inline(always)]
19573 fn inline_align(_context: fidl::encoding::Context) -> usize {
19574 8
19575 }
19576
19577 #[inline(always)]
19578 fn inline_size(_context: fidl::encoding::Context) -> usize {
19579 16
19580 }
19581 }
19582
19583 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PacketHeader, D>
19584 for &PacketHeader
19585 {
19586 unsafe fn encode(
19587 self,
19588 encoder: &mut fidl::encoding::Encoder<'_, D>,
19589 offset: usize,
19590 mut depth: fidl::encoding::Depth,
19591 ) -> fidl::Result<()> {
19592 encoder.debug_check_bounds::<PacketHeader>(offset);
19593 let max_ordinal: u64 = self.max_ordinal_present();
19595 encoder.write_num(max_ordinal, offset);
19596 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19597 if max_ordinal == 0 {
19599 return Ok(());
19600 }
19601 depth.increment()?;
19602 let envelope_size = 8;
19603 let bytes_len = max_ordinal as usize * envelope_size;
19604 #[allow(unused_variables)]
19605 let offset = encoder.out_of_line_offset(bytes_len);
19606 let mut _prev_end_offset: usize = 0;
19607 if 1 > max_ordinal {
19608 return Ok(());
19609 }
19610
19611 let cur_offset: usize = (1 - 1) * envelope_size;
19614
19615 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19617
19618 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19623 self.buffer_lifetime_ordinal
19624 .as_ref()
19625 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19626 encoder,
19627 offset + cur_offset,
19628 depth,
19629 )?;
19630
19631 _prev_end_offset = cur_offset + envelope_size;
19632 if 2 > max_ordinal {
19633 return Ok(());
19634 }
19635
19636 let cur_offset: usize = (2 - 1) * envelope_size;
19639
19640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19642
19643 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19648 self.packet_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19649 encoder,
19650 offset + cur_offset,
19651 depth,
19652 )?;
19653
19654 _prev_end_offset = cur_offset + envelope_size;
19655
19656 Ok(())
19657 }
19658 }
19659
19660 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PacketHeader {
19661 #[inline(always)]
19662 fn new_empty() -> Self {
19663 Self::default()
19664 }
19665
19666 unsafe fn decode(
19667 &mut self,
19668 decoder: &mut fidl::encoding::Decoder<'_, D>,
19669 offset: usize,
19670 mut depth: fidl::encoding::Depth,
19671 ) -> fidl::Result<()> {
19672 decoder.debug_check_bounds::<Self>(offset);
19673 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19674 None => return Err(fidl::Error::NotNullable),
19675 Some(len) => len,
19676 };
19677 if len == 0 {
19679 return Ok(());
19680 };
19681 depth.increment()?;
19682 let envelope_size = 8;
19683 let bytes_len = len * envelope_size;
19684 let offset = decoder.out_of_line_offset(bytes_len)?;
19685 let mut _next_ordinal_to_read = 0;
19687 let mut next_offset = offset;
19688 let end_offset = offset + bytes_len;
19689 _next_ordinal_to_read += 1;
19690 if next_offset >= end_offset {
19691 return Ok(());
19692 }
19693
19694 while _next_ordinal_to_read < 1 {
19696 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19697 _next_ordinal_to_read += 1;
19698 next_offset += envelope_size;
19699 }
19700
19701 let next_out_of_line = decoder.next_out_of_line();
19702 let handles_before = decoder.remaining_handles();
19703 if let Some((inlined, num_bytes, num_handles)) =
19704 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19705 {
19706 let member_inline_size =
19707 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19708 if inlined != (member_inline_size <= 4) {
19709 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19710 }
19711 let inner_offset;
19712 let mut inner_depth = depth.clone();
19713 if inlined {
19714 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19715 inner_offset = next_offset;
19716 } else {
19717 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19718 inner_depth.increment()?;
19719 }
19720 let val_ref =
19721 self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19722 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19723 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19724 {
19725 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19726 }
19727 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19728 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19729 }
19730 }
19731
19732 next_offset += envelope_size;
19733 _next_ordinal_to_read += 1;
19734 if next_offset >= end_offset {
19735 return Ok(());
19736 }
19737
19738 while _next_ordinal_to_read < 2 {
19740 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19741 _next_ordinal_to_read += 1;
19742 next_offset += envelope_size;
19743 }
19744
19745 let next_out_of_line = decoder.next_out_of_line();
19746 let handles_before = decoder.remaining_handles();
19747 if let Some((inlined, num_bytes, num_handles)) =
19748 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19749 {
19750 let member_inline_size =
19751 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19752 if inlined != (member_inline_size <= 4) {
19753 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19754 }
19755 let inner_offset;
19756 let mut inner_depth = depth.clone();
19757 if inlined {
19758 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19759 inner_offset = next_offset;
19760 } else {
19761 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19762 inner_depth.increment()?;
19763 }
19764 let val_ref = self.packet_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19765 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19766 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19767 {
19768 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19769 }
19770 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19771 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19772 }
19773 }
19774
19775 next_offset += envelope_size;
19776
19777 while next_offset < end_offset {
19779 _next_ordinal_to_read += 1;
19780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19781 next_offset += envelope_size;
19782 }
19783
19784 Ok(())
19785 }
19786 }
19787
19788 impl StreamBufferConstraints {
19789 #[inline(always)]
19790 fn max_ordinal_present(&self) -> u64 {
19791 if let Some(_) = self.is_physically_contiguous_required {
19792 return 13;
19793 }
19794 if let Some(_) = self.single_buffer_mode_allowed {
19795 return 12;
19796 }
19797 if let Some(_) = self.packet_count_for_client_max {
19798 return 11;
19799 }
19800 if let Some(_) = self.packet_count_for_client_min {
19801 return 10;
19802 }
19803 if let Some(_) = self.packet_count_for_server_max {
19804 return 9;
19805 }
19806 if let Some(_) = self.packet_count_for_server_recommended_max {
19807 return 8;
19808 }
19809 if let Some(_) = self.packet_count_for_server_recommended {
19810 return 7;
19811 }
19812 if let Some(_) = self.packet_count_for_server_min {
19813 return 6;
19814 }
19815 if let Some(_) = self.per_packet_buffer_bytes_max {
19816 return 5;
19817 }
19818 if let Some(_) = self.per_packet_buffer_bytes_recommended {
19819 return 4;
19820 }
19821 if let Some(_) = self.per_packet_buffer_bytes_min {
19822 return 3;
19823 }
19824 if let Some(_) = self.default_settings {
19825 return 2;
19826 }
19827 if let Some(_) = self.buffer_constraints_version_ordinal {
19828 return 1;
19829 }
19830 0
19831 }
19832 }
19833
19834 impl fidl::encoding::ValueTypeMarker for StreamBufferConstraints {
19835 type Borrowed<'a> = &'a Self;
19836 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19837 value
19838 }
19839 }
19840
19841 unsafe impl fidl::encoding::TypeMarker for StreamBufferConstraints {
19842 type Owned = Self;
19843
19844 #[inline(always)]
19845 fn inline_align(_context: fidl::encoding::Context) -> usize {
19846 8
19847 }
19848
19849 #[inline(always)]
19850 fn inline_size(_context: fidl::encoding::Context) -> usize {
19851 16
19852 }
19853 }
19854
19855 unsafe impl<D: fidl::encoding::ResourceDialect>
19856 fidl::encoding::Encode<StreamBufferConstraints, D> for &StreamBufferConstraints
19857 {
19858 unsafe fn encode(
19859 self,
19860 encoder: &mut fidl::encoding::Encoder<'_, D>,
19861 offset: usize,
19862 mut depth: fidl::encoding::Depth,
19863 ) -> fidl::Result<()> {
19864 encoder.debug_check_bounds::<StreamBufferConstraints>(offset);
19865 let max_ordinal: u64 = self.max_ordinal_present();
19867 encoder.write_num(max_ordinal, offset);
19868 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19869 if max_ordinal == 0 {
19871 return Ok(());
19872 }
19873 depth.increment()?;
19874 let envelope_size = 8;
19875 let bytes_len = max_ordinal as usize * envelope_size;
19876 #[allow(unused_variables)]
19877 let offset = encoder.out_of_line_offset(bytes_len);
19878 let mut _prev_end_offset: usize = 0;
19879 if 1 > max_ordinal {
19880 return Ok(());
19881 }
19882
19883 let cur_offset: usize = (1 - 1) * envelope_size;
19886
19887 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19889
19890 fidl::encoding::encode_in_envelope_optional::<u64, D>(
19895 self.buffer_constraints_version_ordinal
19896 .as_ref()
19897 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19898 encoder,
19899 offset + cur_offset,
19900 depth,
19901 )?;
19902
19903 _prev_end_offset = cur_offset + envelope_size;
19904 if 2 > max_ordinal {
19905 return Ok(());
19906 }
19907
19908 let cur_offset: usize = (2 - 1) * envelope_size;
19911
19912 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19914
19915 fidl::encoding::encode_in_envelope_optional::<StreamBufferSettings, D>(
19920 self.default_settings
19921 .as_ref()
19922 .map(<StreamBufferSettings as fidl::encoding::ValueTypeMarker>::borrow),
19923 encoder,
19924 offset + cur_offset,
19925 depth,
19926 )?;
19927
19928 _prev_end_offset = cur_offset + envelope_size;
19929 if 3 > max_ordinal {
19930 return Ok(());
19931 }
19932
19933 let cur_offset: usize = (3 - 1) * envelope_size;
19936
19937 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19939
19940 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19945 self.per_packet_buffer_bytes_min
19946 .as_ref()
19947 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19948 encoder,
19949 offset + cur_offset,
19950 depth,
19951 )?;
19952
19953 _prev_end_offset = cur_offset + envelope_size;
19954 if 4 > max_ordinal {
19955 return Ok(());
19956 }
19957
19958 let cur_offset: usize = (4 - 1) * envelope_size;
19961
19962 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19964
19965 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19970 self.per_packet_buffer_bytes_recommended
19971 .as_ref()
19972 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19973 encoder,
19974 offset + cur_offset,
19975 depth,
19976 )?;
19977
19978 _prev_end_offset = cur_offset + envelope_size;
19979 if 5 > max_ordinal {
19980 return Ok(());
19981 }
19982
19983 let cur_offset: usize = (5 - 1) * envelope_size;
19986
19987 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19989
19990 fidl::encoding::encode_in_envelope_optional::<u32, D>(
19995 self.per_packet_buffer_bytes_max
19996 .as_ref()
19997 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19998 encoder,
19999 offset + cur_offset,
20000 depth,
20001 )?;
20002
20003 _prev_end_offset = cur_offset + envelope_size;
20004 if 6 > max_ordinal {
20005 return Ok(());
20006 }
20007
20008 let cur_offset: usize = (6 - 1) * envelope_size;
20011
20012 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20014
20015 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20020 self.packet_count_for_server_min
20021 .as_ref()
20022 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20023 encoder,
20024 offset + cur_offset,
20025 depth,
20026 )?;
20027
20028 _prev_end_offset = cur_offset + envelope_size;
20029 if 7 > max_ordinal {
20030 return Ok(());
20031 }
20032
20033 let cur_offset: usize = (7 - 1) * envelope_size;
20036
20037 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20039
20040 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20045 self.packet_count_for_server_recommended
20046 .as_ref()
20047 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20048 encoder,
20049 offset + cur_offset,
20050 depth,
20051 )?;
20052
20053 _prev_end_offset = cur_offset + envelope_size;
20054 if 8 > max_ordinal {
20055 return Ok(());
20056 }
20057
20058 let cur_offset: usize = (8 - 1) * envelope_size;
20061
20062 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20064
20065 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20070 self.packet_count_for_server_recommended_max
20071 .as_ref()
20072 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20073 encoder,
20074 offset + cur_offset,
20075 depth,
20076 )?;
20077
20078 _prev_end_offset = cur_offset + envelope_size;
20079 if 9 > max_ordinal {
20080 return Ok(());
20081 }
20082
20083 let cur_offset: usize = (9 - 1) * envelope_size;
20086
20087 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20089
20090 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20095 self.packet_count_for_server_max
20096 .as_ref()
20097 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20098 encoder,
20099 offset + cur_offset,
20100 depth,
20101 )?;
20102
20103 _prev_end_offset = cur_offset + envelope_size;
20104 if 10 > max_ordinal {
20105 return Ok(());
20106 }
20107
20108 let cur_offset: usize = (10 - 1) * envelope_size;
20111
20112 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20114
20115 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20120 self.packet_count_for_client_min
20121 .as_ref()
20122 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20123 encoder,
20124 offset + cur_offset,
20125 depth,
20126 )?;
20127
20128 _prev_end_offset = cur_offset + envelope_size;
20129 if 11 > max_ordinal {
20130 return Ok(());
20131 }
20132
20133 let cur_offset: usize = (11 - 1) * envelope_size;
20136
20137 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20139
20140 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20145 self.packet_count_for_client_max
20146 .as_ref()
20147 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20148 encoder,
20149 offset + cur_offset,
20150 depth,
20151 )?;
20152
20153 _prev_end_offset = cur_offset + envelope_size;
20154 if 12 > max_ordinal {
20155 return Ok(());
20156 }
20157
20158 let cur_offset: usize = (12 - 1) * envelope_size;
20161
20162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20164
20165 fidl::encoding::encode_in_envelope_optional::<bool, D>(
20170 self.single_buffer_mode_allowed
20171 .as_ref()
20172 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20173 encoder,
20174 offset + cur_offset,
20175 depth,
20176 )?;
20177
20178 _prev_end_offset = cur_offset + envelope_size;
20179 if 13 > max_ordinal {
20180 return Ok(());
20181 }
20182
20183 let cur_offset: usize = (13 - 1) * envelope_size;
20186
20187 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20189
20190 fidl::encoding::encode_in_envelope_optional::<bool, D>(
20195 self.is_physically_contiguous_required
20196 .as_ref()
20197 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20198 encoder,
20199 offset + cur_offset,
20200 depth,
20201 )?;
20202
20203 _prev_end_offset = cur_offset + envelope_size;
20204
20205 Ok(())
20206 }
20207 }
20208
20209 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
20210 for StreamBufferConstraints
20211 {
20212 #[inline(always)]
20213 fn new_empty() -> Self {
20214 Self::default()
20215 }
20216
20217 unsafe fn decode(
20218 &mut self,
20219 decoder: &mut fidl::encoding::Decoder<'_, D>,
20220 offset: usize,
20221 mut depth: fidl::encoding::Depth,
20222 ) -> fidl::Result<()> {
20223 decoder.debug_check_bounds::<Self>(offset);
20224 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20225 None => return Err(fidl::Error::NotNullable),
20226 Some(len) => len,
20227 };
20228 if len == 0 {
20230 return Ok(());
20231 };
20232 depth.increment()?;
20233 let envelope_size = 8;
20234 let bytes_len = len * envelope_size;
20235 let offset = decoder.out_of_line_offset(bytes_len)?;
20236 let mut _next_ordinal_to_read = 0;
20238 let mut next_offset = offset;
20239 let end_offset = offset + bytes_len;
20240 _next_ordinal_to_read += 1;
20241 if next_offset >= end_offset {
20242 return Ok(());
20243 }
20244
20245 while _next_ordinal_to_read < 1 {
20247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20248 _next_ordinal_to_read += 1;
20249 next_offset += envelope_size;
20250 }
20251
20252 let next_out_of_line = decoder.next_out_of_line();
20253 let handles_before = decoder.remaining_handles();
20254 if let Some((inlined, num_bytes, num_handles)) =
20255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20256 {
20257 let member_inline_size =
20258 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20259 if inlined != (member_inline_size <= 4) {
20260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20261 }
20262 let inner_offset;
20263 let mut inner_depth = depth.clone();
20264 if inlined {
20265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20266 inner_offset = next_offset;
20267 } else {
20268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20269 inner_depth.increment()?;
20270 }
20271 let val_ref = self
20272 .buffer_constraints_version_ordinal
20273 .get_or_insert_with(|| fidl::new_empty!(u64, D));
20274 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
20275 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20276 {
20277 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20278 }
20279 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20280 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20281 }
20282 }
20283
20284 next_offset += envelope_size;
20285 _next_ordinal_to_read += 1;
20286 if next_offset >= end_offset {
20287 return Ok(());
20288 }
20289
20290 while _next_ordinal_to_read < 2 {
20292 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20293 _next_ordinal_to_read += 1;
20294 next_offset += envelope_size;
20295 }
20296
20297 let next_out_of_line = decoder.next_out_of_line();
20298 let handles_before = decoder.remaining_handles();
20299 if let Some((inlined, num_bytes, num_handles)) =
20300 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20301 {
20302 let member_inline_size =
20303 <StreamBufferSettings as fidl::encoding::TypeMarker>::inline_size(
20304 decoder.context,
20305 );
20306 if inlined != (member_inline_size <= 4) {
20307 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20308 }
20309 let inner_offset;
20310 let mut inner_depth = depth.clone();
20311 if inlined {
20312 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20313 inner_offset = next_offset;
20314 } else {
20315 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20316 inner_depth.increment()?;
20317 }
20318 let val_ref = self
20319 .default_settings
20320 .get_or_insert_with(|| fidl::new_empty!(StreamBufferSettings, D));
20321 fidl::decode!(
20322 StreamBufferSettings,
20323 D,
20324 val_ref,
20325 decoder,
20326 inner_offset,
20327 inner_depth
20328 )?;
20329 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20330 {
20331 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20332 }
20333 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20334 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20335 }
20336 }
20337
20338 next_offset += envelope_size;
20339 _next_ordinal_to_read += 1;
20340 if next_offset >= end_offset {
20341 return Ok(());
20342 }
20343
20344 while _next_ordinal_to_read < 3 {
20346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20347 _next_ordinal_to_read += 1;
20348 next_offset += envelope_size;
20349 }
20350
20351 let next_out_of_line = decoder.next_out_of_line();
20352 let handles_before = decoder.remaining_handles();
20353 if let Some((inlined, num_bytes, num_handles)) =
20354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20355 {
20356 let member_inline_size =
20357 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20358 if inlined != (member_inline_size <= 4) {
20359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20360 }
20361 let inner_offset;
20362 let mut inner_depth = depth.clone();
20363 if inlined {
20364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20365 inner_offset = next_offset;
20366 } else {
20367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20368 inner_depth.increment()?;
20369 }
20370 let val_ref = self
20371 .per_packet_buffer_bytes_min
20372 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20373 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20374 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20375 {
20376 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20377 }
20378 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20379 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20380 }
20381 }
20382
20383 next_offset += envelope_size;
20384 _next_ordinal_to_read += 1;
20385 if next_offset >= end_offset {
20386 return Ok(());
20387 }
20388
20389 while _next_ordinal_to_read < 4 {
20391 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20392 _next_ordinal_to_read += 1;
20393 next_offset += envelope_size;
20394 }
20395
20396 let next_out_of_line = decoder.next_out_of_line();
20397 let handles_before = decoder.remaining_handles();
20398 if let Some((inlined, num_bytes, num_handles)) =
20399 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20400 {
20401 let member_inline_size =
20402 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20403 if inlined != (member_inline_size <= 4) {
20404 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20405 }
20406 let inner_offset;
20407 let mut inner_depth = depth.clone();
20408 if inlined {
20409 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20410 inner_offset = next_offset;
20411 } else {
20412 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20413 inner_depth.increment()?;
20414 }
20415 let val_ref = self
20416 .per_packet_buffer_bytes_recommended
20417 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20418 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20419 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20420 {
20421 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20422 }
20423 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20424 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20425 }
20426 }
20427
20428 next_offset += envelope_size;
20429 _next_ordinal_to_read += 1;
20430 if next_offset >= end_offset {
20431 return Ok(());
20432 }
20433
20434 while _next_ordinal_to_read < 5 {
20436 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20437 _next_ordinal_to_read += 1;
20438 next_offset += envelope_size;
20439 }
20440
20441 let next_out_of_line = decoder.next_out_of_line();
20442 let handles_before = decoder.remaining_handles();
20443 if let Some((inlined, num_bytes, num_handles)) =
20444 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20445 {
20446 let member_inline_size =
20447 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20448 if inlined != (member_inline_size <= 4) {
20449 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20450 }
20451 let inner_offset;
20452 let mut inner_depth = depth.clone();
20453 if inlined {
20454 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20455 inner_offset = next_offset;
20456 } else {
20457 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20458 inner_depth.increment()?;
20459 }
20460 let val_ref = self
20461 .per_packet_buffer_bytes_max
20462 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20463 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20464 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20465 {
20466 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20467 }
20468 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20469 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20470 }
20471 }
20472
20473 next_offset += envelope_size;
20474 _next_ordinal_to_read += 1;
20475 if next_offset >= end_offset {
20476 return Ok(());
20477 }
20478
20479 while _next_ordinal_to_read < 6 {
20481 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20482 _next_ordinal_to_read += 1;
20483 next_offset += envelope_size;
20484 }
20485
20486 let next_out_of_line = decoder.next_out_of_line();
20487 let handles_before = decoder.remaining_handles();
20488 if let Some((inlined, num_bytes, num_handles)) =
20489 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20490 {
20491 let member_inline_size =
20492 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20493 if inlined != (member_inline_size <= 4) {
20494 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20495 }
20496 let inner_offset;
20497 let mut inner_depth = depth.clone();
20498 if inlined {
20499 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20500 inner_offset = next_offset;
20501 } else {
20502 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20503 inner_depth.increment()?;
20504 }
20505 let val_ref = self
20506 .packet_count_for_server_min
20507 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20508 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20509 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20510 {
20511 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20512 }
20513 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20514 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20515 }
20516 }
20517
20518 next_offset += envelope_size;
20519 _next_ordinal_to_read += 1;
20520 if next_offset >= end_offset {
20521 return Ok(());
20522 }
20523
20524 while _next_ordinal_to_read < 7 {
20526 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20527 _next_ordinal_to_read += 1;
20528 next_offset += envelope_size;
20529 }
20530
20531 let next_out_of_line = decoder.next_out_of_line();
20532 let handles_before = decoder.remaining_handles();
20533 if let Some((inlined, num_bytes, num_handles)) =
20534 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20535 {
20536 let member_inline_size =
20537 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20538 if inlined != (member_inline_size <= 4) {
20539 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20540 }
20541 let inner_offset;
20542 let mut inner_depth = depth.clone();
20543 if inlined {
20544 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20545 inner_offset = next_offset;
20546 } else {
20547 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20548 inner_depth.increment()?;
20549 }
20550 let val_ref = self
20551 .packet_count_for_server_recommended
20552 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20553 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20554 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20555 {
20556 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20557 }
20558 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20559 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20560 }
20561 }
20562
20563 next_offset += envelope_size;
20564 _next_ordinal_to_read += 1;
20565 if next_offset >= end_offset {
20566 return Ok(());
20567 }
20568
20569 while _next_ordinal_to_read < 8 {
20571 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20572 _next_ordinal_to_read += 1;
20573 next_offset += envelope_size;
20574 }
20575
20576 let next_out_of_line = decoder.next_out_of_line();
20577 let handles_before = decoder.remaining_handles();
20578 if let Some((inlined, num_bytes, num_handles)) =
20579 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20580 {
20581 let member_inline_size =
20582 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20583 if inlined != (member_inline_size <= 4) {
20584 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20585 }
20586 let inner_offset;
20587 let mut inner_depth = depth.clone();
20588 if inlined {
20589 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20590 inner_offset = next_offset;
20591 } else {
20592 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20593 inner_depth.increment()?;
20594 }
20595 let val_ref = self
20596 .packet_count_for_server_recommended_max
20597 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20598 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20600 {
20601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20602 }
20603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20605 }
20606 }
20607
20608 next_offset += envelope_size;
20609 _next_ordinal_to_read += 1;
20610 if next_offset >= end_offset {
20611 return Ok(());
20612 }
20613
20614 while _next_ordinal_to_read < 9 {
20616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20617 _next_ordinal_to_read += 1;
20618 next_offset += envelope_size;
20619 }
20620
20621 let next_out_of_line = decoder.next_out_of_line();
20622 let handles_before = decoder.remaining_handles();
20623 if let Some((inlined, num_bytes, num_handles)) =
20624 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20625 {
20626 let member_inline_size =
20627 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20628 if inlined != (member_inline_size <= 4) {
20629 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20630 }
20631 let inner_offset;
20632 let mut inner_depth = depth.clone();
20633 if inlined {
20634 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20635 inner_offset = next_offset;
20636 } else {
20637 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20638 inner_depth.increment()?;
20639 }
20640 let val_ref = self
20641 .packet_count_for_server_max
20642 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20643 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20644 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20645 {
20646 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20647 }
20648 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20649 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20650 }
20651 }
20652
20653 next_offset += envelope_size;
20654 _next_ordinal_to_read += 1;
20655 if next_offset >= end_offset {
20656 return Ok(());
20657 }
20658
20659 while _next_ordinal_to_read < 10 {
20661 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20662 _next_ordinal_to_read += 1;
20663 next_offset += envelope_size;
20664 }
20665
20666 let next_out_of_line = decoder.next_out_of_line();
20667 let handles_before = decoder.remaining_handles();
20668 if let Some((inlined, num_bytes, num_handles)) =
20669 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20670 {
20671 let member_inline_size =
20672 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20673 if inlined != (member_inline_size <= 4) {
20674 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20675 }
20676 let inner_offset;
20677 let mut inner_depth = depth.clone();
20678 if inlined {
20679 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20680 inner_offset = next_offset;
20681 } else {
20682 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20683 inner_depth.increment()?;
20684 }
20685 let val_ref = self
20686 .packet_count_for_client_min
20687 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20688 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20689 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20690 {
20691 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20692 }
20693 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20694 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20695 }
20696 }
20697
20698 next_offset += envelope_size;
20699 _next_ordinal_to_read += 1;
20700 if next_offset >= end_offset {
20701 return Ok(());
20702 }
20703
20704 while _next_ordinal_to_read < 11 {
20706 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20707 _next_ordinal_to_read += 1;
20708 next_offset += envelope_size;
20709 }
20710
20711 let next_out_of_line = decoder.next_out_of_line();
20712 let handles_before = decoder.remaining_handles();
20713 if let Some((inlined, num_bytes, num_handles)) =
20714 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20715 {
20716 let member_inline_size =
20717 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20718 if inlined != (member_inline_size <= 4) {
20719 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20720 }
20721 let inner_offset;
20722 let mut inner_depth = depth.clone();
20723 if inlined {
20724 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20725 inner_offset = next_offset;
20726 } else {
20727 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20728 inner_depth.increment()?;
20729 }
20730 let val_ref = self
20731 .packet_count_for_client_max
20732 .get_or_insert_with(|| fidl::new_empty!(u32, D));
20733 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20734 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20735 {
20736 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20737 }
20738 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20739 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20740 }
20741 }
20742
20743 next_offset += envelope_size;
20744 _next_ordinal_to_read += 1;
20745 if next_offset >= end_offset {
20746 return Ok(());
20747 }
20748
20749 while _next_ordinal_to_read < 12 {
20751 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20752 _next_ordinal_to_read += 1;
20753 next_offset += envelope_size;
20754 }
20755
20756 let next_out_of_line = decoder.next_out_of_line();
20757 let handles_before = decoder.remaining_handles();
20758 if let Some((inlined, num_bytes, num_handles)) =
20759 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20760 {
20761 let member_inline_size =
20762 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20763 if inlined != (member_inline_size <= 4) {
20764 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20765 }
20766 let inner_offset;
20767 let mut inner_depth = depth.clone();
20768 if inlined {
20769 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20770 inner_offset = next_offset;
20771 } else {
20772 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20773 inner_depth.increment()?;
20774 }
20775 let val_ref = self
20776 .single_buffer_mode_allowed
20777 .get_or_insert_with(|| fidl::new_empty!(bool, D));
20778 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
20779 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20780 {
20781 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20782 }
20783 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20784 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20785 }
20786 }
20787
20788 next_offset += envelope_size;
20789 _next_ordinal_to_read += 1;
20790 if next_offset >= end_offset {
20791 return Ok(());
20792 }
20793
20794 while _next_ordinal_to_read < 13 {
20796 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20797 _next_ordinal_to_read += 1;
20798 next_offset += envelope_size;
20799 }
20800
20801 let next_out_of_line = decoder.next_out_of_line();
20802 let handles_before = decoder.remaining_handles();
20803 if let Some((inlined, num_bytes, num_handles)) =
20804 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20805 {
20806 let member_inline_size =
20807 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20808 if inlined != (member_inline_size <= 4) {
20809 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20810 }
20811 let inner_offset;
20812 let mut inner_depth = depth.clone();
20813 if inlined {
20814 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20815 inner_offset = next_offset;
20816 } else {
20817 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20818 inner_depth.increment()?;
20819 }
20820 let val_ref = self
20821 .is_physically_contiguous_required
20822 .get_or_insert_with(|| fidl::new_empty!(bool, D));
20823 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
20824 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20825 {
20826 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20827 }
20828 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20829 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20830 }
20831 }
20832
20833 next_offset += envelope_size;
20834
20835 while next_offset < end_offset {
20837 _next_ordinal_to_read += 1;
20838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20839 next_offset += envelope_size;
20840 }
20841
20842 Ok(())
20843 }
20844 }
20845
20846 impl StreamBufferSettings {
20847 #[inline(always)]
20848 fn max_ordinal_present(&self) -> u64 {
20849 if let Some(_) = self.single_buffer_mode {
20850 return 6;
20851 }
20852 if let Some(_) = self.per_packet_buffer_bytes {
20853 return 5;
20854 }
20855 if let Some(_) = self.packet_count_for_client {
20856 return 4;
20857 }
20858 if let Some(_) = self.packet_count_for_server {
20859 return 3;
20860 }
20861 if let Some(_) = self.buffer_constraints_version_ordinal {
20862 return 2;
20863 }
20864 if let Some(_) = self.buffer_lifetime_ordinal {
20865 return 1;
20866 }
20867 0
20868 }
20869 }
20870
20871 impl fidl::encoding::ValueTypeMarker for StreamBufferSettings {
20872 type Borrowed<'a> = &'a Self;
20873 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20874 value
20875 }
20876 }
20877
20878 unsafe impl fidl::encoding::TypeMarker for StreamBufferSettings {
20879 type Owned = Self;
20880
20881 #[inline(always)]
20882 fn inline_align(_context: fidl::encoding::Context) -> usize {
20883 8
20884 }
20885
20886 #[inline(always)]
20887 fn inline_size(_context: fidl::encoding::Context) -> usize {
20888 16
20889 }
20890 }
20891
20892 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamBufferSettings, D>
20893 for &StreamBufferSettings
20894 {
20895 unsafe fn encode(
20896 self,
20897 encoder: &mut fidl::encoding::Encoder<'_, D>,
20898 offset: usize,
20899 mut depth: fidl::encoding::Depth,
20900 ) -> fidl::Result<()> {
20901 encoder.debug_check_bounds::<StreamBufferSettings>(offset);
20902 let max_ordinal: u64 = self.max_ordinal_present();
20904 encoder.write_num(max_ordinal, offset);
20905 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20906 if max_ordinal == 0 {
20908 return Ok(());
20909 }
20910 depth.increment()?;
20911 let envelope_size = 8;
20912 let bytes_len = max_ordinal as usize * envelope_size;
20913 #[allow(unused_variables)]
20914 let offset = encoder.out_of_line_offset(bytes_len);
20915 let mut _prev_end_offset: usize = 0;
20916 if 1 > max_ordinal {
20917 return Ok(());
20918 }
20919
20920 let cur_offset: usize = (1 - 1) * envelope_size;
20923
20924 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20926
20927 fidl::encoding::encode_in_envelope_optional::<u64, D>(
20932 self.buffer_lifetime_ordinal
20933 .as_ref()
20934 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
20935 encoder,
20936 offset + cur_offset,
20937 depth,
20938 )?;
20939
20940 _prev_end_offset = cur_offset + envelope_size;
20941 if 2 > max_ordinal {
20942 return Ok(());
20943 }
20944
20945 let cur_offset: usize = (2 - 1) * envelope_size;
20948
20949 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20951
20952 fidl::encoding::encode_in_envelope_optional::<u64, D>(
20957 self.buffer_constraints_version_ordinal
20958 .as_ref()
20959 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
20960 encoder,
20961 offset + cur_offset,
20962 depth,
20963 )?;
20964
20965 _prev_end_offset = cur_offset + envelope_size;
20966 if 3 > max_ordinal {
20967 return Ok(());
20968 }
20969
20970 let cur_offset: usize = (3 - 1) * envelope_size;
20973
20974 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20976
20977 fidl::encoding::encode_in_envelope_optional::<u32, D>(
20982 self.packet_count_for_server
20983 .as_ref()
20984 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20985 encoder,
20986 offset + cur_offset,
20987 depth,
20988 )?;
20989
20990 _prev_end_offset = cur_offset + envelope_size;
20991 if 4 > max_ordinal {
20992 return Ok(());
20993 }
20994
20995 let cur_offset: usize = (4 - 1) * envelope_size;
20998
20999 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21001
21002 fidl::encoding::encode_in_envelope_optional::<u32, D>(
21007 self.packet_count_for_client
21008 .as_ref()
21009 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21010 encoder,
21011 offset + cur_offset,
21012 depth,
21013 )?;
21014
21015 _prev_end_offset = cur_offset + envelope_size;
21016 if 5 > max_ordinal {
21017 return Ok(());
21018 }
21019
21020 let cur_offset: usize = (5 - 1) * envelope_size;
21023
21024 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21026
21027 fidl::encoding::encode_in_envelope_optional::<u32, D>(
21032 self.per_packet_buffer_bytes
21033 .as_ref()
21034 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21035 encoder,
21036 offset + cur_offset,
21037 depth,
21038 )?;
21039
21040 _prev_end_offset = cur_offset + envelope_size;
21041 if 6 > max_ordinal {
21042 return Ok(());
21043 }
21044
21045 let cur_offset: usize = (6 - 1) * envelope_size;
21048
21049 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21051
21052 fidl::encoding::encode_in_envelope_optional::<bool, D>(
21057 self.single_buffer_mode
21058 .as_ref()
21059 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21060 encoder,
21061 offset + cur_offset,
21062 depth,
21063 )?;
21064
21065 _prev_end_offset = cur_offset + envelope_size;
21066
21067 Ok(())
21068 }
21069 }
21070
21071 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamBufferSettings {
21072 #[inline(always)]
21073 fn new_empty() -> Self {
21074 Self::default()
21075 }
21076
21077 unsafe fn decode(
21078 &mut self,
21079 decoder: &mut fidl::encoding::Decoder<'_, D>,
21080 offset: usize,
21081 mut depth: fidl::encoding::Depth,
21082 ) -> fidl::Result<()> {
21083 decoder.debug_check_bounds::<Self>(offset);
21084 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21085 None => return Err(fidl::Error::NotNullable),
21086 Some(len) => len,
21087 };
21088 if len == 0 {
21090 return Ok(());
21091 };
21092 depth.increment()?;
21093 let envelope_size = 8;
21094 let bytes_len = len * envelope_size;
21095 let offset = decoder.out_of_line_offset(bytes_len)?;
21096 let mut _next_ordinal_to_read = 0;
21098 let mut next_offset = offset;
21099 let end_offset = offset + bytes_len;
21100 _next_ordinal_to_read += 1;
21101 if next_offset >= end_offset {
21102 return Ok(());
21103 }
21104
21105 while _next_ordinal_to_read < 1 {
21107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21108 _next_ordinal_to_read += 1;
21109 next_offset += envelope_size;
21110 }
21111
21112 let next_out_of_line = decoder.next_out_of_line();
21113 let handles_before = decoder.remaining_handles();
21114 if let Some((inlined, num_bytes, num_handles)) =
21115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21116 {
21117 let member_inline_size =
21118 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21119 if inlined != (member_inline_size <= 4) {
21120 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21121 }
21122 let inner_offset;
21123 let mut inner_depth = depth.clone();
21124 if inlined {
21125 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21126 inner_offset = next_offset;
21127 } else {
21128 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21129 inner_depth.increment()?;
21130 }
21131 let val_ref =
21132 self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21133 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21135 {
21136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21137 }
21138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21140 }
21141 }
21142
21143 next_offset += envelope_size;
21144 _next_ordinal_to_read += 1;
21145 if next_offset >= end_offset {
21146 return Ok(());
21147 }
21148
21149 while _next_ordinal_to_read < 2 {
21151 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21152 _next_ordinal_to_read += 1;
21153 next_offset += envelope_size;
21154 }
21155
21156 let next_out_of_line = decoder.next_out_of_line();
21157 let handles_before = decoder.remaining_handles();
21158 if let Some((inlined, num_bytes, num_handles)) =
21159 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21160 {
21161 let member_inline_size =
21162 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21163 if inlined != (member_inline_size <= 4) {
21164 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21165 }
21166 let inner_offset;
21167 let mut inner_depth = depth.clone();
21168 if inlined {
21169 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21170 inner_offset = next_offset;
21171 } else {
21172 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21173 inner_depth.increment()?;
21174 }
21175 let val_ref = self
21176 .buffer_constraints_version_ordinal
21177 .get_or_insert_with(|| fidl::new_empty!(u64, D));
21178 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21179 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21180 {
21181 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21182 }
21183 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21184 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21185 }
21186 }
21187
21188 next_offset += envelope_size;
21189 _next_ordinal_to_read += 1;
21190 if next_offset >= end_offset {
21191 return Ok(());
21192 }
21193
21194 while _next_ordinal_to_read < 3 {
21196 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21197 _next_ordinal_to_read += 1;
21198 next_offset += envelope_size;
21199 }
21200
21201 let next_out_of_line = decoder.next_out_of_line();
21202 let handles_before = decoder.remaining_handles();
21203 if let Some((inlined, num_bytes, num_handles)) =
21204 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21205 {
21206 let member_inline_size =
21207 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21208 if inlined != (member_inline_size <= 4) {
21209 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21210 }
21211 let inner_offset;
21212 let mut inner_depth = depth.clone();
21213 if inlined {
21214 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21215 inner_offset = next_offset;
21216 } else {
21217 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21218 inner_depth.increment()?;
21219 }
21220 let val_ref =
21221 self.packet_count_for_server.get_or_insert_with(|| fidl::new_empty!(u32, D));
21222 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21223 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21224 {
21225 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21226 }
21227 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21228 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21229 }
21230 }
21231
21232 next_offset += envelope_size;
21233 _next_ordinal_to_read += 1;
21234 if next_offset >= end_offset {
21235 return Ok(());
21236 }
21237
21238 while _next_ordinal_to_read < 4 {
21240 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21241 _next_ordinal_to_read += 1;
21242 next_offset += envelope_size;
21243 }
21244
21245 let next_out_of_line = decoder.next_out_of_line();
21246 let handles_before = decoder.remaining_handles();
21247 if let Some((inlined, num_bytes, num_handles)) =
21248 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21249 {
21250 let member_inline_size =
21251 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21252 if inlined != (member_inline_size <= 4) {
21253 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21254 }
21255 let inner_offset;
21256 let mut inner_depth = depth.clone();
21257 if inlined {
21258 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21259 inner_offset = next_offset;
21260 } else {
21261 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21262 inner_depth.increment()?;
21263 }
21264 let val_ref =
21265 self.packet_count_for_client.get_or_insert_with(|| fidl::new_empty!(u32, D));
21266 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21267 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21268 {
21269 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21270 }
21271 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21272 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21273 }
21274 }
21275
21276 next_offset += envelope_size;
21277 _next_ordinal_to_read += 1;
21278 if next_offset >= end_offset {
21279 return Ok(());
21280 }
21281
21282 while _next_ordinal_to_read < 5 {
21284 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21285 _next_ordinal_to_read += 1;
21286 next_offset += envelope_size;
21287 }
21288
21289 let next_out_of_line = decoder.next_out_of_line();
21290 let handles_before = decoder.remaining_handles();
21291 if let Some((inlined, num_bytes, num_handles)) =
21292 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21293 {
21294 let member_inline_size =
21295 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21296 if inlined != (member_inline_size <= 4) {
21297 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21298 }
21299 let inner_offset;
21300 let mut inner_depth = depth.clone();
21301 if inlined {
21302 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21303 inner_offset = next_offset;
21304 } else {
21305 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21306 inner_depth.increment()?;
21307 }
21308 let val_ref =
21309 self.per_packet_buffer_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
21310 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21311 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21312 {
21313 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21314 }
21315 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21316 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21317 }
21318 }
21319
21320 next_offset += envelope_size;
21321 _next_ordinal_to_read += 1;
21322 if next_offset >= end_offset {
21323 return Ok(());
21324 }
21325
21326 while _next_ordinal_to_read < 6 {
21328 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21329 _next_ordinal_to_read += 1;
21330 next_offset += envelope_size;
21331 }
21332
21333 let next_out_of_line = decoder.next_out_of_line();
21334 let handles_before = decoder.remaining_handles();
21335 if let Some((inlined, num_bytes, num_handles)) =
21336 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21337 {
21338 let member_inline_size =
21339 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21340 if inlined != (member_inline_size <= 4) {
21341 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21342 }
21343 let inner_offset;
21344 let mut inner_depth = depth.clone();
21345 if inlined {
21346 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21347 inner_offset = next_offset;
21348 } else {
21349 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21350 inner_depth.increment()?;
21351 }
21352 let val_ref =
21353 self.single_buffer_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
21354 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21355 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21356 {
21357 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21358 }
21359 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21360 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21361 }
21362 }
21363
21364 next_offset += envelope_size;
21365
21366 while next_offset < end_offset {
21368 _next_ordinal_to_read += 1;
21369 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21370 next_offset += envelope_size;
21371 }
21372
21373 Ok(())
21374 }
21375 }
21376
21377 impl StreamOutputConstraints {
21378 #[inline(always)]
21379 fn max_ordinal_present(&self) -> u64 {
21380 if let Some(_) = self.buffer_constraints {
21381 return 3;
21382 }
21383 if let Some(_) = self.buffer_constraints_action_required {
21384 return 2;
21385 }
21386 if let Some(_) = self.stream_lifetime_ordinal {
21387 return 1;
21388 }
21389 0
21390 }
21391 }
21392
21393 impl fidl::encoding::ValueTypeMarker for StreamOutputConstraints {
21394 type Borrowed<'a> = &'a Self;
21395 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21396 value
21397 }
21398 }
21399
21400 unsafe impl fidl::encoding::TypeMarker for StreamOutputConstraints {
21401 type Owned = Self;
21402
21403 #[inline(always)]
21404 fn inline_align(_context: fidl::encoding::Context) -> usize {
21405 8
21406 }
21407
21408 #[inline(always)]
21409 fn inline_size(_context: fidl::encoding::Context) -> usize {
21410 16
21411 }
21412 }
21413
21414 unsafe impl<D: fidl::encoding::ResourceDialect>
21415 fidl::encoding::Encode<StreamOutputConstraints, D> for &StreamOutputConstraints
21416 {
21417 unsafe fn encode(
21418 self,
21419 encoder: &mut fidl::encoding::Encoder<'_, D>,
21420 offset: usize,
21421 mut depth: fidl::encoding::Depth,
21422 ) -> fidl::Result<()> {
21423 encoder.debug_check_bounds::<StreamOutputConstraints>(offset);
21424 let max_ordinal: u64 = self.max_ordinal_present();
21426 encoder.write_num(max_ordinal, offset);
21427 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21428 if max_ordinal == 0 {
21430 return Ok(());
21431 }
21432 depth.increment()?;
21433 let envelope_size = 8;
21434 let bytes_len = max_ordinal as usize * envelope_size;
21435 #[allow(unused_variables)]
21436 let offset = encoder.out_of_line_offset(bytes_len);
21437 let mut _prev_end_offset: usize = 0;
21438 if 1 > max_ordinal {
21439 return Ok(());
21440 }
21441
21442 let cur_offset: usize = (1 - 1) * envelope_size;
21445
21446 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21448
21449 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21454 self.stream_lifetime_ordinal
21455 .as_ref()
21456 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21457 encoder,
21458 offset + cur_offset,
21459 depth,
21460 )?;
21461
21462 _prev_end_offset = cur_offset + envelope_size;
21463 if 2 > max_ordinal {
21464 return Ok(());
21465 }
21466
21467 let cur_offset: usize = (2 - 1) * envelope_size;
21470
21471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21473
21474 fidl::encoding::encode_in_envelope_optional::<bool, D>(
21479 self.buffer_constraints_action_required
21480 .as_ref()
21481 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21482 encoder,
21483 offset + cur_offset,
21484 depth,
21485 )?;
21486
21487 _prev_end_offset = cur_offset + envelope_size;
21488 if 3 > max_ordinal {
21489 return Ok(());
21490 }
21491
21492 let cur_offset: usize = (3 - 1) * envelope_size;
21495
21496 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21498
21499 fidl::encoding::encode_in_envelope_optional::<StreamBufferConstraints, D>(
21504 self.buffer_constraints
21505 .as_ref()
21506 .map(<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow),
21507 encoder,
21508 offset + cur_offset,
21509 depth,
21510 )?;
21511
21512 _prev_end_offset = cur_offset + envelope_size;
21513
21514 Ok(())
21515 }
21516 }
21517
21518 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
21519 for StreamOutputConstraints
21520 {
21521 #[inline(always)]
21522 fn new_empty() -> Self {
21523 Self::default()
21524 }
21525
21526 unsafe fn decode(
21527 &mut self,
21528 decoder: &mut fidl::encoding::Decoder<'_, D>,
21529 offset: usize,
21530 mut depth: fidl::encoding::Depth,
21531 ) -> fidl::Result<()> {
21532 decoder.debug_check_bounds::<Self>(offset);
21533 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21534 None => return Err(fidl::Error::NotNullable),
21535 Some(len) => len,
21536 };
21537 if len == 0 {
21539 return Ok(());
21540 };
21541 depth.increment()?;
21542 let envelope_size = 8;
21543 let bytes_len = len * envelope_size;
21544 let offset = decoder.out_of_line_offset(bytes_len)?;
21545 let mut _next_ordinal_to_read = 0;
21547 let mut next_offset = offset;
21548 let end_offset = offset + bytes_len;
21549 _next_ordinal_to_read += 1;
21550 if next_offset >= end_offset {
21551 return Ok(());
21552 }
21553
21554 while _next_ordinal_to_read < 1 {
21556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21557 _next_ordinal_to_read += 1;
21558 next_offset += envelope_size;
21559 }
21560
21561 let next_out_of_line = decoder.next_out_of_line();
21562 let handles_before = decoder.remaining_handles();
21563 if let Some((inlined, num_bytes, num_handles)) =
21564 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21565 {
21566 let member_inline_size =
21567 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21568 if inlined != (member_inline_size <= 4) {
21569 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21570 }
21571 let inner_offset;
21572 let mut inner_depth = depth.clone();
21573 if inlined {
21574 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21575 inner_offset = next_offset;
21576 } else {
21577 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21578 inner_depth.increment()?;
21579 }
21580 let val_ref =
21581 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21582 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21584 {
21585 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21586 }
21587 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21588 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21589 }
21590 }
21591
21592 next_offset += envelope_size;
21593 _next_ordinal_to_read += 1;
21594 if next_offset >= end_offset {
21595 return Ok(());
21596 }
21597
21598 while _next_ordinal_to_read < 2 {
21600 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21601 _next_ordinal_to_read += 1;
21602 next_offset += envelope_size;
21603 }
21604
21605 let next_out_of_line = decoder.next_out_of_line();
21606 let handles_before = decoder.remaining_handles();
21607 if let Some((inlined, num_bytes, num_handles)) =
21608 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21609 {
21610 let member_inline_size =
21611 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21612 if inlined != (member_inline_size <= 4) {
21613 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21614 }
21615 let inner_offset;
21616 let mut inner_depth = depth.clone();
21617 if inlined {
21618 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21619 inner_offset = next_offset;
21620 } else {
21621 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21622 inner_depth.increment()?;
21623 }
21624 let val_ref = self
21625 .buffer_constraints_action_required
21626 .get_or_insert_with(|| fidl::new_empty!(bool, D));
21627 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21628 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21629 {
21630 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21631 }
21632 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21633 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21634 }
21635 }
21636
21637 next_offset += envelope_size;
21638 _next_ordinal_to_read += 1;
21639 if next_offset >= end_offset {
21640 return Ok(());
21641 }
21642
21643 while _next_ordinal_to_read < 3 {
21645 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21646 _next_ordinal_to_read += 1;
21647 next_offset += envelope_size;
21648 }
21649
21650 let next_out_of_line = decoder.next_out_of_line();
21651 let handles_before = decoder.remaining_handles();
21652 if let Some((inlined, num_bytes, num_handles)) =
21653 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21654 {
21655 let member_inline_size =
21656 <StreamBufferConstraints as fidl::encoding::TypeMarker>::inline_size(
21657 decoder.context,
21658 );
21659 if inlined != (member_inline_size <= 4) {
21660 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21661 }
21662 let inner_offset;
21663 let mut inner_depth = depth.clone();
21664 if inlined {
21665 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21666 inner_offset = next_offset;
21667 } else {
21668 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21669 inner_depth.increment()?;
21670 }
21671 let val_ref = self
21672 .buffer_constraints
21673 .get_or_insert_with(|| fidl::new_empty!(StreamBufferConstraints, D));
21674 fidl::decode!(
21675 StreamBufferConstraints,
21676 D,
21677 val_ref,
21678 decoder,
21679 inner_offset,
21680 inner_depth
21681 )?;
21682 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21683 {
21684 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21685 }
21686 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21687 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21688 }
21689 }
21690
21691 next_offset += envelope_size;
21692
21693 while next_offset < end_offset {
21695 _next_ordinal_to_read += 1;
21696 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21697 next_offset += envelope_size;
21698 }
21699
21700 Ok(())
21701 }
21702 }
21703
21704 impl StreamOutputFormat {
21705 #[inline(always)]
21706 fn max_ordinal_present(&self) -> u64 {
21707 if let Some(_) = self.format_details {
21708 return 2;
21709 }
21710 if let Some(_) = self.stream_lifetime_ordinal {
21711 return 1;
21712 }
21713 0
21714 }
21715 }
21716
21717 impl fidl::encoding::ValueTypeMarker for StreamOutputFormat {
21718 type Borrowed<'a> = &'a Self;
21719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21720 value
21721 }
21722 }
21723
21724 unsafe impl fidl::encoding::TypeMarker for StreamOutputFormat {
21725 type Owned = Self;
21726
21727 #[inline(always)]
21728 fn inline_align(_context: fidl::encoding::Context) -> usize {
21729 8
21730 }
21731
21732 #[inline(always)]
21733 fn inline_size(_context: fidl::encoding::Context) -> usize {
21734 16
21735 }
21736 }
21737
21738 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamOutputFormat, D>
21739 for &StreamOutputFormat
21740 {
21741 unsafe fn encode(
21742 self,
21743 encoder: &mut fidl::encoding::Encoder<'_, D>,
21744 offset: usize,
21745 mut depth: fidl::encoding::Depth,
21746 ) -> fidl::Result<()> {
21747 encoder.debug_check_bounds::<StreamOutputFormat>(offset);
21748 let max_ordinal: u64 = self.max_ordinal_present();
21750 encoder.write_num(max_ordinal, offset);
21751 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21752 if max_ordinal == 0 {
21754 return Ok(());
21755 }
21756 depth.increment()?;
21757 let envelope_size = 8;
21758 let bytes_len = max_ordinal as usize * envelope_size;
21759 #[allow(unused_variables)]
21760 let offset = encoder.out_of_line_offset(bytes_len);
21761 let mut _prev_end_offset: usize = 0;
21762 if 1 > max_ordinal {
21763 return Ok(());
21764 }
21765
21766 let cur_offset: usize = (1 - 1) * envelope_size;
21769
21770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21772
21773 fidl::encoding::encode_in_envelope_optional::<u64, D>(
21778 self.stream_lifetime_ordinal
21779 .as_ref()
21780 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21781 encoder,
21782 offset + cur_offset,
21783 depth,
21784 )?;
21785
21786 _prev_end_offset = cur_offset + envelope_size;
21787 if 2 > max_ordinal {
21788 return Ok(());
21789 }
21790
21791 let cur_offset: usize = (2 - 1) * envelope_size;
21794
21795 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21797
21798 fidl::encoding::encode_in_envelope_optional::<FormatDetails, D>(
21803 self.format_details
21804 .as_ref()
21805 .map(<FormatDetails as fidl::encoding::ValueTypeMarker>::borrow),
21806 encoder,
21807 offset + cur_offset,
21808 depth,
21809 )?;
21810
21811 _prev_end_offset = cur_offset + envelope_size;
21812
21813 Ok(())
21814 }
21815 }
21816
21817 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamOutputFormat {
21818 #[inline(always)]
21819 fn new_empty() -> Self {
21820 Self::default()
21821 }
21822
21823 unsafe fn decode(
21824 &mut self,
21825 decoder: &mut fidl::encoding::Decoder<'_, D>,
21826 offset: usize,
21827 mut depth: fidl::encoding::Depth,
21828 ) -> fidl::Result<()> {
21829 decoder.debug_check_bounds::<Self>(offset);
21830 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21831 None => return Err(fidl::Error::NotNullable),
21832 Some(len) => len,
21833 };
21834 if len == 0 {
21836 return Ok(());
21837 };
21838 depth.increment()?;
21839 let envelope_size = 8;
21840 let bytes_len = len * envelope_size;
21841 let offset = decoder.out_of_line_offset(bytes_len)?;
21842 let mut _next_ordinal_to_read = 0;
21844 let mut next_offset = offset;
21845 let end_offset = offset + bytes_len;
21846 _next_ordinal_to_read += 1;
21847 if next_offset >= end_offset {
21848 return Ok(());
21849 }
21850
21851 while _next_ordinal_to_read < 1 {
21853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21854 _next_ordinal_to_read += 1;
21855 next_offset += envelope_size;
21856 }
21857
21858 let next_out_of_line = decoder.next_out_of_line();
21859 let handles_before = decoder.remaining_handles();
21860 if let Some((inlined, num_bytes, num_handles)) =
21861 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21862 {
21863 let member_inline_size =
21864 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21865 if inlined != (member_inline_size <= 4) {
21866 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21867 }
21868 let inner_offset;
21869 let mut inner_depth = depth.clone();
21870 if inlined {
21871 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21872 inner_offset = next_offset;
21873 } else {
21874 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21875 inner_depth.increment()?;
21876 }
21877 let val_ref =
21878 self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21879 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21880 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21881 {
21882 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21883 }
21884 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21885 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21886 }
21887 }
21888
21889 next_offset += envelope_size;
21890 _next_ordinal_to_read += 1;
21891 if next_offset >= end_offset {
21892 return Ok(());
21893 }
21894
21895 while _next_ordinal_to_read < 2 {
21897 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21898 _next_ordinal_to_read += 1;
21899 next_offset += envelope_size;
21900 }
21901
21902 let next_out_of_line = decoder.next_out_of_line();
21903 let handles_before = decoder.remaining_handles();
21904 if let Some((inlined, num_bytes, num_handles)) =
21905 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21906 {
21907 let member_inline_size =
21908 <FormatDetails as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21909 if inlined != (member_inline_size <= 4) {
21910 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21911 }
21912 let inner_offset;
21913 let mut inner_depth = depth.clone();
21914 if inlined {
21915 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21916 inner_offset = next_offset;
21917 } else {
21918 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21919 inner_depth.increment()?;
21920 }
21921 let val_ref =
21922 self.format_details.get_or_insert_with(|| fidl::new_empty!(FormatDetails, D));
21923 fidl::decode!(FormatDetails, D, val_ref, decoder, inner_offset, inner_depth)?;
21924 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21925 {
21926 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21927 }
21928 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21929 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21930 }
21931 }
21932
21933 next_offset += envelope_size;
21934
21935 while next_offset < end_offset {
21937 _next_ordinal_to_read += 1;
21938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21939 next_offset += envelope_size;
21940 }
21941
21942 Ok(())
21943 }
21944 }
21945
21946 impl UsageStateDucked {
21947 #[inline(always)]
21948 fn max_ordinal_present(&self) -> u64 {
21949 0
21950 }
21951 }
21952
21953 impl fidl::encoding::ValueTypeMarker for UsageStateDucked {
21954 type Borrowed<'a> = &'a Self;
21955 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21956 value
21957 }
21958 }
21959
21960 unsafe impl fidl::encoding::TypeMarker for UsageStateDucked {
21961 type Owned = Self;
21962
21963 #[inline(always)]
21964 fn inline_align(_context: fidl::encoding::Context) -> usize {
21965 8
21966 }
21967
21968 #[inline(always)]
21969 fn inline_size(_context: fidl::encoding::Context) -> usize {
21970 16
21971 }
21972 }
21973
21974 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateDucked, D>
21975 for &UsageStateDucked
21976 {
21977 unsafe fn encode(
21978 self,
21979 encoder: &mut fidl::encoding::Encoder<'_, D>,
21980 offset: usize,
21981 mut depth: fidl::encoding::Depth,
21982 ) -> fidl::Result<()> {
21983 encoder.debug_check_bounds::<UsageStateDucked>(offset);
21984 let max_ordinal: u64 = self.max_ordinal_present();
21986 encoder.write_num(max_ordinal, offset);
21987 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21988 if max_ordinal == 0 {
21990 return Ok(());
21991 }
21992 depth.increment()?;
21993 let envelope_size = 8;
21994 let bytes_len = max_ordinal as usize * envelope_size;
21995 #[allow(unused_variables)]
21996 let offset = encoder.out_of_line_offset(bytes_len);
21997 let mut _prev_end_offset: usize = 0;
21998
21999 Ok(())
22000 }
22001 }
22002
22003 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateDucked {
22004 #[inline(always)]
22005 fn new_empty() -> Self {
22006 Self::default()
22007 }
22008
22009 unsafe fn decode(
22010 &mut self,
22011 decoder: &mut fidl::encoding::Decoder<'_, D>,
22012 offset: usize,
22013 mut depth: fidl::encoding::Depth,
22014 ) -> fidl::Result<()> {
22015 decoder.debug_check_bounds::<Self>(offset);
22016 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22017 None => return Err(fidl::Error::NotNullable),
22018 Some(len) => len,
22019 };
22020 if len == 0 {
22022 return Ok(());
22023 };
22024 depth.increment()?;
22025 let envelope_size = 8;
22026 let bytes_len = len * envelope_size;
22027 let offset = decoder.out_of_line_offset(bytes_len)?;
22028 let mut _next_ordinal_to_read = 0;
22030 let mut next_offset = offset;
22031 let end_offset = offset + bytes_len;
22032
22033 while next_offset < end_offset {
22035 _next_ordinal_to_read += 1;
22036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22037 next_offset += envelope_size;
22038 }
22039
22040 Ok(())
22041 }
22042 }
22043
22044 impl UsageStateMuted {
22045 #[inline(always)]
22046 fn max_ordinal_present(&self) -> u64 {
22047 0
22048 }
22049 }
22050
22051 impl fidl::encoding::ValueTypeMarker for UsageStateMuted {
22052 type Borrowed<'a> = &'a Self;
22053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22054 value
22055 }
22056 }
22057
22058 unsafe impl fidl::encoding::TypeMarker for UsageStateMuted {
22059 type Owned = Self;
22060
22061 #[inline(always)]
22062 fn inline_align(_context: fidl::encoding::Context) -> usize {
22063 8
22064 }
22065
22066 #[inline(always)]
22067 fn inline_size(_context: fidl::encoding::Context) -> usize {
22068 16
22069 }
22070 }
22071
22072 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateMuted, D>
22073 for &UsageStateMuted
22074 {
22075 unsafe fn encode(
22076 self,
22077 encoder: &mut fidl::encoding::Encoder<'_, D>,
22078 offset: usize,
22079 mut depth: fidl::encoding::Depth,
22080 ) -> fidl::Result<()> {
22081 encoder.debug_check_bounds::<UsageStateMuted>(offset);
22082 let max_ordinal: u64 = self.max_ordinal_present();
22084 encoder.write_num(max_ordinal, offset);
22085 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22086 if max_ordinal == 0 {
22088 return Ok(());
22089 }
22090 depth.increment()?;
22091 let envelope_size = 8;
22092 let bytes_len = max_ordinal as usize * envelope_size;
22093 #[allow(unused_variables)]
22094 let offset = encoder.out_of_line_offset(bytes_len);
22095 let mut _prev_end_offset: usize = 0;
22096
22097 Ok(())
22098 }
22099 }
22100
22101 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateMuted {
22102 #[inline(always)]
22103 fn new_empty() -> Self {
22104 Self::default()
22105 }
22106
22107 unsafe fn decode(
22108 &mut self,
22109 decoder: &mut fidl::encoding::Decoder<'_, D>,
22110 offset: usize,
22111 mut depth: fidl::encoding::Depth,
22112 ) -> fidl::Result<()> {
22113 decoder.debug_check_bounds::<Self>(offset);
22114 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22115 None => return Err(fidl::Error::NotNullable),
22116 Some(len) => len,
22117 };
22118 if len == 0 {
22120 return Ok(());
22121 };
22122 depth.increment()?;
22123 let envelope_size = 8;
22124 let bytes_len = len * envelope_size;
22125 let offset = decoder.out_of_line_offset(bytes_len)?;
22126 let mut _next_ordinal_to_read = 0;
22128 let mut next_offset = offset;
22129 let end_offset = offset + bytes_len;
22130
22131 while next_offset < end_offset {
22133 _next_ordinal_to_read += 1;
22134 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22135 next_offset += envelope_size;
22136 }
22137
22138 Ok(())
22139 }
22140 }
22141
22142 impl UsageStateUnadjusted {
22143 #[inline(always)]
22144 fn max_ordinal_present(&self) -> u64 {
22145 0
22146 }
22147 }
22148
22149 impl fidl::encoding::ValueTypeMarker for UsageStateUnadjusted {
22150 type Borrowed<'a> = &'a Self;
22151 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22152 value
22153 }
22154 }
22155
22156 unsafe impl fidl::encoding::TypeMarker for UsageStateUnadjusted {
22157 type Owned = Self;
22158
22159 #[inline(always)]
22160 fn inline_align(_context: fidl::encoding::Context) -> usize {
22161 8
22162 }
22163
22164 #[inline(always)]
22165 fn inline_size(_context: fidl::encoding::Context) -> usize {
22166 16
22167 }
22168 }
22169
22170 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateUnadjusted, D>
22171 for &UsageStateUnadjusted
22172 {
22173 unsafe fn encode(
22174 self,
22175 encoder: &mut fidl::encoding::Encoder<'_, D>,
22176 offset: usize,
22177 mut depth: fidl::encoding::Depth,
22178 ) -> fidl::Result<()> {
22179 encoder.debug_check_bounds::<UsageStateUnadjusted>(offset);
22180 let max_ordinal: u64 = self.max_ordinal_present();
22182 encoder.write_num(max_ordinal, offset);
22183 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22184 if max_ordinal == 0 {
22186 return Ok(());
22187 }
22188 depth.increment()?;
22189 let envelope_size = 8;
22190 let bytes_len = max_ordinal as usize * envelope_size;
22191 #[allow(unused_variables)]
22192 let offset = encoder.out_of_line_offset(bytes_len);
22193 let mut _prev_end_offset: usize = 0;
22194
22195 Ok(())
22196 }
22197 }
22198
22199 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateUnadjusted {
22200 #[inline(always)]
22201 fn new_empty() -> Self {
22202 Self::default()
22203 }
22204
22205 unsafe fn decode(
22206 &mut self,
22207 decoder: &mut fidl::encoding::Decoder<'_, D>,
22208 offset: usize,
22209 mut depth: fidl::encoding::Depth,
22210 ) -> fidl::Result<()> {
22211 decoder.debug_check_bounds::<Self>(offset);
22212 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22213 None => return Err(fidl::Error::NotNullable),
22214 Some(len) => len,
22215 };
22216 if len == 0 {
22218 return Ok(());
22219 };
22220 depth.increment()?;
22221 let envelope_size = 8;
22222 let bytes_len = len * envelope_size;
22223 let offset = decoder.out_of_line_offset(bytes_len)?;
22224 let mut _next_ordinal_to_read = 0;
22226 let mut next_offset = offset;
22227 let end_offset = offset + bytes_len;
22228
22229 while next_offset < end_offset {
22231 _next_ordinal_to_read += 1;
22232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22233 next_offset += envelope_size;
22234 }
22235
22236 Ok(())
22237 }
22238 }
22239
22240 impl fidl::encoding::ValueTypeMarker for AacBitRate {
22241 type Borrowed<'a> = &'a Self;
22242 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22243 value
22244 }
22245 }
22246
22247 unsafe impl fidl::encoding::TypeMarker for AacBitRate {
22248 type Owned = Self;
22249
22250 #[inline(always)]
22251 fn inline_align(_context: fidl::encoding::Context) -> usize {
22252 8
22253 }
22254
22255 #[inline(always)]
22256 fn inline_size(_context: fidl::encoding::Context) -> usize {
22257 16
22258 }
22259 }
22260
22261 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacBitRate, D>
22262 for &AacBitRate
22263 {
22264 #[inline]
22265 unsafe fn encode(
22266 self,
22267 encoder: &mut fidl::encoding::Encoder<'_, D>,
22268 offset: usize,
22269 _depth: fidl::encoding::Depth,
22270 ) -> fidl::Result<()> {
22271 encoder.debug_check_bounds::<AacBitRate>(offset);
22272 encoder.write_num::<u64>(self.ordinal(), offset);
22273 match self {
22274 AacBitRate::Constant(ref val) => {
22275 fidl::encoding::encode_in_envelope::<AacConstantBitRate, D>(
22276 <AacConstantBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22277 encoder,
22278 offset + 8,
22279 _depth,
22280 )
22281 }
22282 AacBitRate::Variable(ref val) => {
22283 fidl::encoding::encode_in_envelope::<AacVariableBitRate, D>(
22284 <AacVariableBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22285 encoder,
22286 offset + 8,
22287 _depth,
22288 )
22289 }
22290 }
22291 }
22292 }
22293
22294 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacBitRate {
22295 #[inline(always)]
22296 fn new_empty() -> Self {
22297 Self::Constant(fidl::new_empty!(AacConstantBitRate, D))
22298 }
22299
22300 #[inline]
22301 unsafe fn decode(
22302 &mut self,
22303 decoder: &mut fidl::encoding::Decoder<'_, D>,
22304 offset: usize,
22305 mut depth: fidl::encoding::Depth,
22306 ) -> fidl::Result<()> {
22307 decoder.debug_check_bounds::<Self>(offset);
22308 #[allow(unused_variables)]
22309 let next_out_of_line = decoder.next_out_of_line();
22310 let handles_before = decoder.remaining_handles();
22311 let (ordinal, inlined, num_bytes, num_handles) =
22312 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22313
22314 let member_inline_size = match ordinal {
22315 1 => {
22316 <AacConstantBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22317 }
22318 2 => {
22319 <AacVariableBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22320 }
22321 _ => return Err(fidl::Error::UnknownUnionTag),
22322 };
22323
22324 if inlined != (member_inline_size <= 4) {
22325 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22326 }
22327 let _inner_offset;
22328 if inlined {
22329 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22330 _inner_offset = offset + 8;
22331 } else {
22332 depth.increment()?;
22333 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22334 }
22335 match ordinal {
22336 1 => {
22337 #[allow(irrefutable_let_patterns)]
22338 if let AacBitRate::Constant(_) = self {
22339 } else {
22341 *self = AacBitRate::Constant(fidl::new_empty!(AacConstantBitRate, D));
22343 }
22344 #[allow(irrefutable_let_patterns)]
22345 if let AacBitRate::Constant(ref mut val) = self {
22346 fidl::decode!(AacConstantBitRate, D, val, decoder, _inner_offset, depth)?;
22347 } else {
22348 unreachable!()
22349 }
22350 }
22351 2 => {
22352 #[allow(irrefutable_let_patterns)]
22353 if let AacBitRate::Variable(_) = self {
22354 } else {
22356 *self = AacBitRate::Variable(fidl::new_empty!(AacVariableBitRate, D));
22358 }
22359 #[allow(irrefutable_let_patterns)]
22360 if let AacBitRate::Variable(ref mut val) = self {
22361 fidl::decode!(AacVariableBitRate, D, val, decoder, _inner_offset, depth)?;
22362 } else {
22363 unreachable!()
22364 }
22365 }
22366 ordinal => panic!("unexpected ordinal {:?}", ordinal),
22367 }
22368 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22369 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22370 }
22371 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22372 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22373 }
22374 Ok(())
22375 }
22376 }
22377
22378 impl fidl::encoding::ValueTypeMarker for AacTransport {
22379 type Borrowed<'a> = &'a Self;
22380 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22381 value
22382 }
22383 }
22384
22385 unsafe impl fidl::encoding::TypeMarker for AacTransport {
22386 type Owned = Self;
22387
22388 #[inline(always)]
22389 fn inline_align(_context: fidl::encoding::Context) -> usize {
22390 8
22391 }
22392
22393 #[inline(always)]
22394 fn inline_size(_context: fidl::encoding::Context) -> usize {
22395 16
22396 }
22397 }
22398
22399 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransport, D>
22400 for &AacTransport
22401 {
22402 #[inline]
22403 unsafe fn encode(
22404 self,
22405 encoder: &mut fidl::encoding::Encoder<'_, D>,
22406 offset: usize,
22407 _depth: fidl::encoding::Depth,
22408 ) -> fidl::Result<()> {
22409 encoder.debug_check_bounds::<AacTransport>(offset);
22410 encoder.write_num::<u64>(self.ordinal(), offset);
22411 match self {
22412 AacTransport::Raw(ref val) => {
22413 fidl::encoding::encode_in_envelope::<AacTransportRaw, D>(
22414 <AacTransportRaw as fidl::encoding::ValueTypeMarker>::borrow(val),
22415 encoder,
22416 offset + 8,
22417 _depth,
22418 )
22419 }
22420 AacTransport::Latm(ref val) => {
22421 fidl::encoding::encode_in_envelope::<AacTransportLatm, D>(
22422 <AacTransportLatm as fidl::encoding::ValueTypeMarker>::borrow(val),
22423 encoder,
22424 offset + 8,
22425 _depth,
22426 )
22427 }
22428 AacTransport::Adts(ref val) => {
22429 fidl::encoding::encode_in_envelope::<AacTransportAdts, D>(
22430 <AacTransportAdts as fidl::encoding::ValueTypeMarker>::borrow(val),
22431 encoder,
22432 offset + 8,
22433 _depth,
22434 )
22435 }
22436 AacTransport::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22437 }
22438 }
22439 }
22440
22441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransport {
22442 #[inline(always)]
22443 fn new_empty() -> Self {
22444 Self::__SourceBreaking { unknown_ordinal: 0 }
22445 }
22446
22447 #[inline]
22448 unsafe fn decode(
22449 &mut self,
22450 decoder: &mut fidl::encoding::Decoder<'_, D>,
22451 offset: usize,
22452 mut depth: fidl::encoding::Depth,
22453 ) -> fidl::Result<()> {
22454 decoder.debug_check_bounds::<Self>(offset);
22455 #[allow(unused_variables)]
22456 let next_out_of_line = decoder.next_out_of_line();
22457 let handles_before = decoder.remaining_handles();
22458 let (ordinal, inlined, num_bytes, num_handles) =
22459 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22460
22461 let member_inline_size = match ordinal {
22462 1 => <AacTransportRaw as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22463 2 => <AacTransportLatm as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22464 3 => <AacTransportAdts as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22465 0 => return Err(fidl::Error::UnknownUnionTag),
22466 _ => num_bytes as usize,
22467 };
22468
22469 if inlined != (member_inline_size <= 4) {
22470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22471 }
22472 let _inner_offset;
22473 if inlined {
22474 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22475 _inner_offset = offset + 8;
22476 } else {
22477 depth.increment()?;
22478 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22479 }
22480 match ordinal {
22481 1 => {
22482 #[allow(irrefutable_let_patterns)]
22483 if let AacTransport::Raw(_) = self {
22484 } else {
22486 *self = AacTransport::Raw(fidl::new_empty!(AacTransportRaw, D));
22488 }
22489 #[allow(irrefutable_let_patterns)]
22490 if let AacTransport::Raw(ref mut val) = self {
22491 fidl::decode!(AacTransportRaw, D, val, decoder, _inner_offset, depth)?;
22492 } else {
22493 unreachable!()
22494 }
22495 }
22496 2 => {
22497 #[allow(irrefutable_let_patterns)]
22498 if let AacTransport::Latm(_) = self {
22499 } else {
22501 *self = AacTransport::Latm(fidl::new_empty!(AacTransportLatm, D));
22503 }
22504 #[allow(irrefutable_let_patterns)]
22505 if let AacTransport::Latm(ref mut val) = self {
22506 fidl::decode!(AacTransportLatm, D, val, decoder, _inner_offset, depth)?;
22507 } else {
22508 unreachable!()
22509 }
22510 }
22511 3 => {
22512 #[allow(irrefutable_let_patterns)]
22513 if let AacTransport::Adts(_) = self {
22514 } else {
22516 *self = AacTransport::Adts(fidl::new_empty!(AacTransportAdts, D));
22518 }
22519 #[allow(irrefutable_let_patterns)]
22520 if let AacTransport::Adts(ref mut val) = self {
22521 fidl::decode!(AacTransportAdts, D, val, decoder, _inner_offset, depth)?;
22522 } else {
22523 unreachable!()
22524 }
22525 }
22526 #[allow(deprecated)]
22527 ordinal => {
22528 for _ in 0..num_handles {
22529 decoder.drop_next_handle()?;
22530 }
22531 *self = AacTransport::__SourceBreaking { unknown_ordinal: ordinal };
22532 }
22533 }
22534 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22535 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22536 }
22537 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22538 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22539 }
22540 Ok(())
22541 }
22542 }
22543
22544 impl fidl::encoding::ValueTypeMarker for AudioCapturerConfiguration {
22545 type Borrowed<'a> = &'a Self;
22546 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22547 value
22548 }
22549 }
22550
22551 unsafe impl fidl::encoding::TypeMarker for AudioCapturerConfiguration {
22552 type Owned = Self;
22553
22554 #[inline(always)]
22555 fn inline_align(_context: fidl::encoding::Context) -> usize {
22556 8
22557 }
22558
22559 #[inline(always)]
22560 fn inline_size(_context: fidl::encoding::Context) -> usize {
22561 16
22562 }
22563 }
22564
22565 unsafe impl<D: fidl::encoding::ResourceDialect>
22566 fidl::encoding::Encode<AudioCapturerConfiguration, D> for &AudioCapturerConfiguration
22567 {
22568 #[inline]
22569 unsafe fn encode(
22570 self,
22571 encoder: &mut fidl::encoding::Encoder<'_, D>,
22572 offset: usize,
22573 _depth: fidl::encoding::Depth,
22574 ) -> fidl::Result<()> {
22575 encoder.debug_check_bounds::<AudioCapturerConfiguration>(offset);
22576 encoder.write_num::<u64>(self.ordinal(), offset);
22577 match self {
22578 AudioCapturerConfiguration::Loopback(ref val) => fidl::encoding::encode_in_envelope::<
22579 LoopbackAudioCapturerConfiguration,
22580 D,
22581 >(
22582 <LoopbackAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22583 val,
22584 ),
22585 encoder,
22586 offset + 8,
22587 _depth,
22588 ),
22589 AudioCapturerConfiguration::Input(ref val) => fidl::encoding::encode_in_envelope::<
22590 InputAudioCapturerConfiguration,
22591 D,
22592 >(
22593 <InputAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22594 val,
22595 ),
22596 encoder,
22597 offset + 8,
22598 _depth,
22599 ),
22600 }
22601 }
22602 }
22603
22604 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
22605 for AudioCapturerConfiguration
22606 {
22607 #[inline(always)]
22608 fn new_empty() -> Self {
22609 Self::Loopback(fidl::new_empty!(LoopbackAudioCapturerConfiguration, D))
22610 }
22611
22612 #[inline]
22613 unsafe fn decode(
22614 &mut self,
22615 decoder: &mut fidl::encoding::Decoder<'_, D>,
22616 offset: usize,
22617 mut depth: fidl::encoding::Depth,
22618 ) -> fidl::Result<()> {
22619 decoder.debug_check_bounds::<Self>(offset);
22620 #[allow(unused_variables)]
22621 let next_out_of_line = decoder.next_out_of_line();
22622 let handles_before = decoder.remaining_handles();
22623 let (ordinal, inlined, num_bytes, num_handles) =
22624 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22625
22626 let member_inline_size = match ordinal {
22627 1 => {
22628 <LoopbackAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22629 decoder.context,
22630 )
22631 }
22632 2 => <InputAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22633 decoder.context,
22634 ),
22635 _ => return Err(fidl::Error::UnknownUnionTag),
22636 };
22637
22638 if inlined != (member_inline_size <= 4) {
22639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22640 }
22641 let _inner_offset;
22642 if inlined {
22643 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22644 _inner_offset = offset + 8;
22645 } else {
22646 depth.increment()?;
22647 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22648 }
22649 match ordinal {
22650 1 => {
22651 #[allow(irrefutable_let_patterns)]
22652 if let AudioCapturerConfiguration::Loopback(_) = self {
22653 } else {
22655 *self = AudioCapturerConfiguration::Loopback(fidl::new_empty!(
22657 LoopbackAudioCapturerConfiguration,
22658 D
22659 ));
22660 }
22661 #[allow(irrefutable_let_patterns)]
22662 if let AudioCapturerConfiguration::Loopback(ref mut val) = self {
22663 fidl::decode!(
22664 LoopbackAudioCapturerConfiguration,
22665 D,
22666 val,
22667 decoder,
22668 _inner_offset,
22669 depth
22670 )?;
22671 } else {
22672 unreachable!()
22673 }
22674 }
22675 2 => {
22676 #[allow(irrefutable_let_patterns)]
22677 if let AudioCapturerConfiguration::Input(_) = self {
22678 } else {
22680 *self = AudioCapturerConfiguration::Input(fidl::new_empty!(
22682 InputAudioCapturerConfiguration,
22683 D
22684 ));
22685 }
22686 #[allow(irrefutable_let_patterns)]
22687 if let AudioCapturerConfiguration::Input(ref mut val) = self {
22688 fidl::decode!(
22689 InputAudioCapturerConfiguration,
22690 D,
22691 val,
22692 decoder,
22693 _inner_offset,
22694 depth
22695 )?;
22696 } else {
22697 unreachable!()
22698 }
22699 }
22700 ordinal => panic!("unexpected ordinal {:?}", ordinal),
22701 }
22702 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22703 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22704 }
22705 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22706 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22707 }
22708 Ok(())
22709 }
22710 }
22711
22712 impl fidl::encoding::ValueTypeMarker for AudioCompressedFormat {
22713 type Borrowed<'a> = &'a Self;
22714 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22715 value
22716 }
22717 }
22718
22719 unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormat {
22720 type Owned = Self;
22721
22722 #[inline(always)]
22723 fn inline_align(_context: fidl::encoding::Context) -> usize {
22724 8
22725 }
22726
22727 #[inline(always)]
22728 fn inline_size(_context: fidl::encoding::Context) -> usize {
22729 16
22730 }
22731 }
22732
22733 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioCompressedFormat, D>
22734 for &AudioCompressedFormat
22735 {
22736 #[inline]
22737 unsafe fn encode(
22738 self,
22739 encoder: &mut fidl::encoding::Encoder<'_, D>,
22740 offset: usize,
22741 _depth: fidl::encoding::Depth,
22742 ) -> fidl::Result<()> {
22743 encoder.debug_check_bounds::<AudioCompressedFormat>(offset);
22744 encoder.write_num::<u64>(self.ordinal(), offset);
22745 match self {
22746 AudioCompressedFormat::Aac(ref val) => {
22747 fidl::encoding::encode_in_envelope::<AudioCompressedFormatAac, D>(
22748 <AudioCompressedFormatAac as fidl::encoding::ValueTypeMarker>::borrow(val),
22749 encoder,
22750 offset + 8,
22751 _depth,
22752 )
22753 }
22754 AudioCompressedFormat::Sbc(ref val) => {
22755 fidl::encoding::encode_in_envelope::<AudioCompressedFormatSbc, D>(
22756 <AudioCompressedFormatSbc as fidl::encoding::ValueTypeMarker>::borrow(val),
22757 encoder,
22758 offset + 8,
22759 _depth,
22760 )
22761 }
22762 AudioCompressedFormat::Cvsd(ref val) => {
22763 fidl::encoding::encode_in_envelope::<AudioCompressedFormatCvsd, D>(
22764 <AudioCompressedFormatCvsd as fidl::encoding::ValueTypeMarker>::borrow(val),
22765 encoder,
22766 offset + 8,
22767 _depth,
22768 )
22769 }
22770 AudioCompressedFormat::Lc3(ref val) => {
22771 fidl::encoding::encode_in_envelope::<AudioCompressedFormatLc3, D>(
22772 <AudioCompressedFormatLc3 as fidl::encoding::ValueTypeMarker>::borrow(val),
22773 encoder,
22774 offset + 8,
22775 _depth,
22776 )
22777 }
22778 AudioCompressedFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22779 }
22780 }
22781 }
22782
22783 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCompressedFormat {
22784 #[inline(always)]
22785 fn new_empty() -> Self {
22786 Self::__SourceBreaking { unknown_ordinal: 0 }
22787 }
22788
22789 #[inline]
22790 unsafe fn decode(
22791 &mut self,
22792 decoder: &mut fidl::encoding::Decoder<'_, D>,
22793 offset: usize,
22794 mut depth: fidl::encoding::Depth,
22795 ) -> fidl::Result<()> {
22796 decoder.debug_check_bounds::<Self>(offset);
22797 #[allow(unused_variables)]
22798 let next_out_of_line = decoder.next_out_of_line();
22799 let handles_before = decoder.remaining_handles();
22800 let (ordinal, inlined, num_bytes, num_handles) =
22801 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22802
22803 let member_inline_size = match ordinal {
22804 1 => <AudioCompressedFormatAac as fidl::encoding::TypeMarker>::inline_size(
22805 decoder.context,
22806 ),
22807 2 => <AudioCompressedFormatSbc as fidl::encoding::TypeMarker>::inline_size(
22808 decoder.context,
22809 ),
22810 3 => <AudioCompressedFormatCvsd as fidl::encoding::TypeMarker>::inline_size(
22811 decoder.context,
22812 ),
22813 4 => <AudioCompressedFormatLc3 as fidl::encoding::TypeMarker>::inline_size(
22814 decoder.context,
22815 ),
22816 0 => return Err(fidl::Error::UnknownUnionTag),
22817 _ => num_bytes as usize,
22818 };
22819
22820 if inlined != (member_inline_size <= 4) {
22821 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22822 }
22823 let _inner_offset;
22824 if inlined {
22825 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22826 _inner_offset = offset + 8;
22827 } else {
22828 depth.increment()?;
22829 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22830 }
22831 match ordinal {
22832 1 => {
22833 #[allow(irrefutable_let_patterns)]
22834 if let AudioCompressedFormat::Aac(_) = self {
22835 } else {
22837 *self = AudioCompressedFormat::Aac(fidl::new_empty!(
22839 AudioCompressedFormatAac,
22840 D
22841 ));
22842 }
22843 #[allow(irrefutable_let_patterns)]
22844 if let AudioCompressedFormat::Aac(ref mut val) = self {
22845 fidl::decode!(
22846 AudioCompressedFormatAac,
22847 D,
22848 val,
22849 decoder,
22850 _inner_offset,
22851 depth
22852 )?;
22853 } else {
22854 unreachable!()
22855 }
22856 }
22857 2 => {
22858 #[allow(irrefutable_let_patterns)]
22859 if let AudioCompressedFormat::Sbc(_) = self {
22860 } else {
22862 *self = AudioCompressedFormat::Sbc(fidl::new_empty!(
22864 AudioCompressedFormatSbc,
22865 D
22866 ));
22867 }
22868 #[allow(irrefutable_let_patterns)]
22869 if let AudioCompressedFormat::Sbc(ref mut val) = self {
22870 fidl::decode!(
22871 AudioCompressedFormatSbc,
22872 D,
22873 val,
22874 decoder,
22875 _inner_offset,
22876 depth
22877 )?;
22878 } else {
22879 unreachable!()
22880 }
22881 }
22882 3 => {
22883 #[allow(irrefutable_let_patterns)]
22884 if let AudioCompressedFormat::Cvsd(_) = self {
22885 } else {
22887 *self = AudioCompressedFormat::Cvsd(fidl::new_empty!(
22889 AudioCompressedFormatCvsd,
22890 D
22891 ));
22892 }
22893 #[allow(irrefutable_let_patterns)]
22894 if let AudioCompressedFormat::Cvsd(ref mut val) = self {
22895 fidl::decode!(
22896 AudioCompressedFormatCvsd,
22897 D,
22898 val,
22899 decoder,
22900 _inner_offset,
22901 depth
22902 )?;
22903 } else {
22904 unreachable!()
22905 }
22906 }
22907 4 => {
22908 #[allow(irrefutable_let_patterns)]
22909 if let AudioCompressedFormat::Lc3(_) = self {
22910 } else {
22912 *self = AudioCompressedFormat::Lc3(fidl::new_empty!(
22914 AudioCompressedFormatLc3,
22915 D
22916 ));
22917 }
22918 #[allow(irrefutable_let_patterns)]
22919 if let AudioCompressedFormat::Lc3(ref mut val) = self {
22920 fidl::decode!(
22921 AudioCompressedFormatLc3,
22922 D,
22923 val,
22924 decoder,
22925 _inner_offset,
22926 depth
22927 )?;
22928 } else {
22929 unreachable!()
22930 }
22931 }
22932 #[allow(deprecated)]
22933 ordinal => {
22934 for _ in 0..num_handles {
22935 decoder.drop_next_handle()?;
22936 }
22937 *self = AudioCompressedFormat::__SourceBreaking { unknown_ordinal: ordinal };
22938 }
22939 }
22940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22941 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22942 }
22943 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22944 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22945 }
22946 Ok(())
22947 }
22948 }
22949
22950 impl fidl::encoding::ValueTypeMarker for AudioConsumerError {
22951 type Borrowed<'a> = &'a Self;
22952 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22953 value
22954 }
22955 }
22956
22957 unsafe impl fidl::encoding::TypeMarker for AudioConsumerError {
22958 type Owned = Self;
22959
22960 #[inline(always)]
22961 fn inline_align(_context: fidl::encoding::Context) -> usize {
22962 8
22963 }
22964
22965 #[inline(always)]
22966 fn inline_size(_context: fidl::encoding::Context) -> usize {
22967 16
22968 }
22969 }
22970
22971 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerError, D>
22972 for &AudioConsumerError
22973 {
22974 #[inline]
22975 unsafe fn encode(
22976 self,
22977 encoder: &mut fidl::encoding::Encoder<'_, D>,
22978 offset: usize,
22979 _depth: fidl::encoding::Depth,
22980 ) -> fidl::Result<()> {
22981 encoder.debug_check_bounds::<AudioConsumerError>(offset);
22982 encoder.write_num::<u64>(self.ordinal(), offset);
22983 match self {
22984 AudioConsumerError::PlaceHolder(ref val) => {
22985 fidl::encoding::encode_in_envelope::<Void, D>(
22986 <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
22987 encoder,
22988 offset + 8,
22989 _depth,
22990 )
22991 }
22992 }
22993 }
22994 }
22995
22996 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerError {
22997 #[inline(always)]
22998 fn new_empty() -> Self {
22999 Self::PlaceHolder(fidl::new_empty!(Void, D))
23000 }
23001
23002 #[inline]
23003 unsafe fn decode(
23004 &mut self,
23005 decoder: &mut fidl::encoding::Decoder<'_, D>,
23006 offset: usize,
23007 mut depth: fidl::encoding::Depth,
23008 ) -> fidl::Result<()> {
23009 decoder.debug_check_bounds::<Self>(offset);
23010 #[allow(unused_variables)]
23011 let next_out_of_line = decoder.next_out_of_line();
23012 let handles_before = decoder.remaining_handles();
23013 let (ordinal, inlined, num_bytes, num_handles) =
23014 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23015
23016 let member_inline_size = match ordinal {
23017 1 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23018 _ => return Err(fidl::Error::UnknownUnionTag),
23019 };
23020
23021 if inlined != (member_inline_size <= 4) {
23022 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23023 }
23024 let _inner_offset;
23025 if inlined {
23026 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23027 _inner_offset = offset + 8;
23028 } else {
23029 depth.increment()?;
23030 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23031 }
23032 match ordinal {
23033 1 => {
23034 #[allow(irrefutable_let_patterns)]
23035 if let AudioConsumerError::PlaceHolder(_) = self {
23036 } else {
23038 *self = AudioConsumerError::PlaceHolder(fidl::new_empty!(Void, D));
23040 }
23041 #[allow(irrefutable_let_patterns)]
23042 if let AudioConsumerError::PlaceHolder(ref mut val) = self {
23043 fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
23044 } else {
23045 unreachable!()
23046 }
23047 }
23048 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23049 }
23050 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23051 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23052 }
23053 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23054 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23055 }
23056 Ok(())
23057 }
23058 }
23059
23060 impl fidl::encoding::ValueTypeMarker for AudioFormat {
23061 type Borrowed<'a> = &'a Self;
23062 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23063 value
23064 }
23065 }
23066
23067 unsafe impl fidl::encoding::TypeMarker for AudioFormat {
23068 type Owned = Self;
23069
23070 #[inline(always)]
23071 fn inline_align(_context: fidl::encoding::Context) -> usize {
23072 8
23073 }
23074
23075 #[inline(always)]
23076 fn inline_size(_context: fidl::encoding::Context) -> usize {
23077 16
23078 }
23079 }
23080
23081 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioFormat, D>
23082 for &AudioFormat
23083 {
23084 #[inline]
23085 unsafe fn encode(
23086 self,
23087 encoder: &mut fidl::encoding::Encoder<'_, D>,
23088 offset: usize,
23089 _depth: fidl::encoding::Depth,
23090 ) -> fidl::Result<()> {
23091 encoder.debug_check_bounds::<AudioFormat>(offset);
23092 encoder.write_num::<u64>(self.ordinal(), offset);
23093 match self {
23094 AudioFormat::Compressed(ref val) => {
23095 fidl::encoding::encode_in_envelope::<AudioCompressedFormat, D>(
23096 <AudioCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23097 encoder,
23098 offset + 8,
23099 _depth,
23100 )
23101 }
23102 AudioFormat::Uncompressed(ref val) => {
23103 fidl::encoding::encode_in_envelope::<AudioUncompressedFormat, D>(
23104 <AudioUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23105 encoder,
23106 offset + 8,
23107 _depth,
23108 )
23109 }
23110 }
23111 }
23112 }
23113
23114 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioFormat {
23115 #[inline(always)]
23116 fn new_empty() -> Self {
23117 Self::Compressed(fidl::new_empty!(AudioCompressedFormat, D))
23118 }
23119
23120 #[inline]
23121 unsafe fn decode(
23122 &mut self,
23123 decoder: &mut fidl::encoding::Decoder<'_, D>,
23124 offset: usize,
23125 mut depth: fidl::encoding::Depth,
23126 ) -> fidl::Result<()> {
23127 decoder.debug_check_bounds::<Self>(offset);
23128 #[allow(unused_variables)]
23129 let next_out_of_line = decoder.next_out_of_line();
23130 let handles_before = decoder.remaining_handles();
23131 let (ordinal, inlined, num_bytes, num_handles) =
23132 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23133
23134 let member_inline_size = match ordinal {
23135 1 => <AudioCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23136 decoder.context,
23137 ),
23138 2 => <AudioUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23139 decoder.context,
23140 ),
23141 _ => return Err(fidl::Error::UnknownUnionTag),
23142 };
23143
23144 if inlined != (member_inline_size <= 4) {
23145 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23146 }
23147 let _inner_offset;
23148 if inlined {
23149 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23150 _inner_offset = offset + 8;
23151 } else {
23152 depth.increment()?;
23153 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23154 }
23155 match ordinal {
23156 1 => {
23157 #[allow(irrefutable_let_patterns)]
23158 if let AudioFormat::Compressed(_) = self {
23159 } else {
23161 *self = AudioFormat::Compressed(fidl::new_empty!(AudioCompressedFormat, D));
23163 }
23164 #[allow(irrefutable_let_patterns)]
23165 if let AudioFormat::Compressed(ref mut val) = self {
23166 fidl::decode!(
23167 AudioCompressedFormat,
23168 D,
23169 val,
23170 decoder,
23171 _inner_offset,
23172 depth
23173 )?;
23174 } else {
23175 unreachable!()
23176 }
23177 }
23178 2 => {
23179 #[allow(irrefutable_let_patterns)]
23180 if let AudioFormat::Uncompressed(_) = self {
23181 } else {
23183 *self =
23185 AudioFormat::Uncompressed(fidl::new_empty!(AudioUncompressedFormat, D));
23186 }
23187 #[allow(irrefutable_let_patterns)]
23188 if let AudioFormat::Uncompressed(ref mut val) = self {
23189 fidl::decode!(
23190 AudioUncompressedFormat,
23191 D,
23192 val,
23193 decoder,
23194 _inner_offset,
23195 depth
23196 )?;
23197 } else {
23198 unreachable!()
23199 }
23200 }
23201 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23202 }
23203 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23205 }
23206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23208 }
23209 Ok(())
23210 }
23211 }
23212
23213 impl fidl::encoding::ValueTypeMarker for AudioUncompressedFormat {
23214 type Borrowed<'a> = &'a Self;
23215 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23216 value
23217 }
23218 }
23219
23220 unsafe impl fidl::encoding::TypeMarker for AudioUncompressedFormat {
23221 type Owned = Self;
23222
23223 #[inline(always)]
23224 fn inline_align(_context: fidl::encoding::Context) -> usize {
23225 8
23226 }
23227
23228 #[inline(always)]
23229 fn inline_size(_context: fidl::encoding::Context) -> usize {
23230 16
23231 }
23232 }
23233
23234 unsafe impl<D: fidl::encoding::ResourceDialect>
23235 fidl::encoding::Encode<AudioUncompressedFormat, D> for &AudioUncompressedFormat
23236 {
23237 #[inline]
23238 unsafe fn encode(
23239 self,
23240 encoder: &mut fidl::encoding::Encoder<'_, D>,
23241 offset: usize,
23242 _depth: fidl::encoding::Depth,
23243 ) -> fidl::Result<()> {
23244 encoder.debug_check_bounds::<AudioUncompressedFormat>(offset);
23245 encoder.write_num::<u64>(self.ordinal(), offset);
23246 match self {
23247 AudioUncompressedFormat::Pcm(ref val) => {
23248 fidl::encoding::encode_in_envelope::<PcmFormat, D>(
23249 <PcmFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23250 encoder,
23251 offset + 8,
23252 _depth,
23253 )
23254 }
23255 }
23256 }
23257 }
23258
23259 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
23260 for AudioUncompressedFormat
23261 {
23262 #[inline(always)]
23263 fn new_empty() -> Self {
23264 Self::Pcm(fidl::new_empty!(PcmFormat, D))
23265 }
23266
23267 #[inline]
23268 unsafe fn decode(
23269 &mut self,
23270 decoder: &mut fidl::encoding::Decoder<'_, D>,
23271 offset: usize,
23272 mut depth: fidl::encoding::Depth,
23273 ) -> fidl::Result<()> {
23274 decoder.debug_check_bounds::<Self>(offset);
23275 #[allow(unused_variables)]
23276 let next_out_of_line = decoder.next_out_of_line();
23277 let handles_before = decoder.remaining_handles();
23278 let (ordinal, inlined, num_bytes, num_handles) =
23279 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23280
23281 let member_inline_size = match ordinal {
23282 1 => <PcmFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23283 _ => return Err(fidl::Error::UnknownUnionTag),
23284 };
23285
23286 if inlined != (member_inline_size <= 4) {
23287 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23288 }
23289 let _inner_offset;
23290 if inlined {
23291 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23292 _inner_offset = offset + 8;
23293 } else {
23294 depth.increment()?;
23295 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23296 }
23297 match ordinal {
23298 1 => {
23299 #[allow(irrefutable_let_patterns)]
23300 if let AudioUncompressedFormat::Pcm(_) = self {
23301 } else {
23303 *self = AudioUncompressedFormat::Pcm(fidl::new_empty!(PcmFormat, D));
23305 }
23306 #[allow(irrefutable_let_patterns)]
23307 if let AudioUncompressedFormat::Pcm(ref mut val) = self {
23308 fidl::decode!(PcmFormat, D, val, decoder, _inner_offset, depth)?;
23309 } else {
23310 unreachable!()
23311 }
23312 }
23313 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23314 }
23315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23316 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23317 }
23318 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23319 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23320 }
23321 Ok(())
23322 }
23323 }
23324
23325 impl fidl::encoding::ValueTypeMarker for CryptoFormat {
23326 type Borrowed<'a> = &'a Self;
23327 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23328 value
23329 }
23330 }
23331
23332 unsafe impl fidl::encoding::TypeMarker for CryptoFormat {
23333 type Owned = Self;
23334
23335 #[inline(always)]
23336 fn inline_align(_context: fidl::encoding::Context) -> usize {
23337 8
23338 }
23339
23340 #[inline(always)]
23341 fn inline_size(_context: fidl::encoding::Context) -> usize {
23342 16
23343 }
23344 }
23345
23346 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CryptoFormat, D>
23347 for &CryptoFormat
23348 {
23349 #[inline]
23350 unsafe fn encode(
23351 self,
23352 encoder: &mut fidl::encoding::Encoder<'_, D>,
23353 offset: usize,
23354 _depth: fidl::encoding::Depth,
23355 ) -> fidl::Result<()> {
23356 encoder.debug_check_bounds::<CryptoFormat>(offset);
23357 encoder.write_num::<u64>(self.ordinal(), offset);
23358 match self {
23359 CryptoFormat::Encrypted(ref val) => {
23360 fidl::encoding::encode_in_envelope::<EncryptedFormat, D>(
23361 <EncryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23362 encoder,
23363 offset + 8,
23364 _depth,
23365 )
23366 }
23367 CryptoFormat::Decrypted(ref val) => {
23368 fidl::encoding::encode_in_envelope::<DecryptedFormat, D>(
23369 <DecryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23370 encoder,
23371 offset + 8,
23372 _depth,
23373 )
23374 }
23375 CryptoFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23376 }
23377 }
23378 }
23379
23380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CryptoFormat {
23381 #[inline(always)]
23382 fn new_empty() -> Self {
23383 Self::__SourceBreaking { unknown_ordinal: 0 }
23384 }
23385
23386 #[inline]
23387 unsafe fn decode(
23388 &mut self,
23389 decoder: &mut fidl::encoding::Decoder<'_, D>,
23390 offset: usize,
23391 mut depth: fidl::encoding::Depth,
23392 ) -> fidl::Result<()> {
23393 decoder.debug_check_bounds::<Self>(offset);
23394 #[allow(unused_variables)]
23395 let next_out_of_line = decoder.next_out_of_line();
23396 let handles_before = decoder.remaining_handles();
23397 let (ordinal, inlined, num_bytes, num_handles) =
23398 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23399
23400 let member_inline_size = match ordinal {
23401 1 => <EncryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23402 2 => <DecryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23403 0 => return Err(fidl::Error::UnknownUnionTag),
23404 _ => num_bytes as usize,
23405 };
23406
23407 if inlined != (member_inline_size <= 4) {
23408 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23409 }
23410 let _inner_offset;
23411 if inlined {
23412 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23413 _inner_offset = offset + 8;
23414 } else {
23415 depth.increment()?;
23416 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23417 }
23418 match ordinal {
23419 1 => {
23420 #[allow(irrefutable_let_patterns)]
23421 if let CryptoFormat::Encrypted(_) = self {
23422 } else {
23424 *self = CryptoFormat::Encrypted(fidl::new_empty!(EncryptedFormat, D));
23426 }
23427 #[allow(irrefutable_let_patterns)]
23428 if let CryptoFormat::Encrypted(ref mut val) = self {
23429 fidl::decode!(EncryptedFormat, D, val, decoder, _inner_offset, depth)?;
23430 } else {
23431 unreachable!()
23432 }
23433 }
23434 2 => {
23435 #[allow(irrefutable_let_patterns)]
23436 if let CryptoFormat::Decrypted(_) = self {
23437 } else {
23439 *self = CryptoFormat::Decrypted(fidl::new_empty!(DecryptedFormat, D));
23441 }
23442 #[allow(irrefutable_let_patterns)]
23443 if let CryptoFormat::Decrypted(ref mut val) = self {
23444 fidl::decode!(DecryptedFormat, D, val, decoder, _inner_offset, depth)?;
23445 } else {
23446 unreachable!()
23447 }
23448 }
23449 #[allow(deprecated)]
23450 ordinal => {
23451 for _ in 0..num_handles {
23452 decoder.drop_next_handle()?;
23453 }
23454 *self = CryptoFormat::__SourceBreaking { unknown_ordinal: ordinal };
23455 }
23456 }
23457 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23458 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23459 }
23460 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23461 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23462 }
23463 Ok(())
23464 }
23465 }
23466
23467 impl fidl::encoding::ValueTypeMarker for DomainFormat {
23468 type Borrowed<'a> = &'a Self;
23469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23470 value
23471 }
23472 }
23473
23474 unsafe impl fidl::encoding::TypeMarker for DomainFormat {
23475 type Owned = Self;
23476
23477 #[inline(always)]
23478 fn inline_align(_context: fidl::encoding::Context) -> usize {
23479 8
23480 }
23481
23482 #[inline(always)]
23483 fn inline_size(_context: fidl::encoding::Context) -> usize {
23484 16
23485 }
23486 }
23487
23488 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DomainFormat, D>
23489 for &DomainFormat
23490 {
23491 #[inline]
23492 unsafe fn encode(
23493 self,
23494 encoder: &mut fidl::encoding::Encoder<'_, D>,
23495 offset: usize,
23496 _depth: fidl::encoding::Depth,
23497 ) -> fidl::Result<()> {
23498 encoder.debug_check_bounds::<DomainFormat>(offset);
23499 encoder.write_num::<u64>(self.ordinal(), offset);
23500 match self {
23501 DomainFormat::Audio(ref val) => {
23502 fidl::encoding::encode_in_envelope::<AudioFormat, D>(
23503 <AudioFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23504 encoder,
23505 offset + 8,
23506 _depth,
23507 )
23508 }
23509 DomainFormat::Video(ref val) => {
23510 fidl::encoding::encode_in_envelope::<VideoFormat, D>(
23511 <VideoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23512 encoder,
23513 offset + 8,
23514 _depth,
23515 )
23516 }
23517 DomainFormat::Crypto(ref val) => {
23518 fidl::encoding::encode_in_envelope::<CryptoFormat, D>(
23519 <CryptoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23520 encoder,
23521 offset + 8,
23522 _depth,
23523 )
23524 }
23525 }
23526 }
23527 }
23528
23529 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DomainFormat {
23530 #[inline(always)]
23531 fn new_empty() -> Self {
23532 Self::Audio(fidl::new_empty!(AudioFormat, D))
23533 }
23534
23535 #[inline]
23536 unsafe fn decode(
23537 &mut self,
23538 decoder: &mut fidl::encoding::Decoder<'_, D>,
23539 offset: usize,
23540 mut depth: fidl::encoding::Depth,
23541 ) -> fidl::Result<()> {
23542 decoder.debug_check_bounds::<Self>(offset);
23543 #[allow(unused_variables)]
23544 let next_out_of_line = decoder.next_out_of_line();
23545 let handles_before = decoder.remaining_handles();
23546 let (ordinal, inlined, num_bytes, num_handles) =
23547 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23548
23549 let member_inline_size = match ordinal {
23550 1 => <AudioFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23551 2 => <VideoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23552 3 => <CryptoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23553 _ => return Err(fidl::Error::UnknownUnionTag),
23554 };
23555
23556 if inlined != (member_inline_size <= 4) {
23557 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23558 }
23559 let _inner_offset;
23560 if inlined {
23561 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23562 _inner_offset = offset + 8;
23563 } else {
23564 depth.increment()?;
23565 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23566 }
23567 match ordinal {
23568 1 => {
23569 #[allow(irrefutable_let_patterns)]
23570 if let DomainFormat::Audio(_) = self {
23571 } else {
23573 *self = DomainFormat::Audio(fidl::new_empty!(AudioFormat, D));
23575 }
23576 #[allow(irrefutable_let_patterns)]
23577 if let DomainFormat::Audio(ref mut val) = self {
23578 fidl::decode!(AudioFormat, D, val, decoder, _inner_offset, depth)?;
23579 } else {
23580 unreachable!()
23581 }
23582 }
23583 2 => {
23584 #[allow(irrefutable_let_patterns)]
23585 if let DomainFormat::Video(_) = self {
23586 } else {
23588 *self = DomainFormat::Video(fidl::new_empty!(VideoFormat, D));
23590 }
23591 #[allow(irrefutable_let_patterns)]
23592 if let DomainFormat::Video(ref mut val) = self {
23593 fidl::decode!(VideoFormat, D, val, decoder, _inner_offset, depth)?;
23594 } else {
23595 unreachable!()
23596 }
23597 }
23598 3 => {
23599 #[allow(irrefutable_let_patterns)]
23600 if let DomainFormat::Crypto(_) = self {
23601 } else {
23603 *self = DomainFormat::Crypto(fidl::new_empty!(CryptoFormat, D));
23605 }
23606 #[allow(irrefutable_let_patterns)]
23607 if let DomainFormat::Crypto(ref mut val) = self {
23608 fidl::decode!(CryptoFormat, D, val, decoder, _inner_offset, depth)?;
23609 } else {
23610 unreachable!()
23611 }
23612 }
23613 ordinal => panic!("unexpected ordinal {:?}", ordinal),
23614 }
23615 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23616 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23617 }
23618 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23619 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23620 }
23621 Ok(())
23622 }
23623 }
23624
23625 impl fidl::encoding::ValueTypeMarker for EncoderSettings {
23626 type Borrowed<'a> = &'a Self;
23627 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23628 value
23629 }
23630 }
23631
23632 unsafe impl fidl::encoding::TypeMarker for EncoderSettings {
23633 type Owned = Self;
23634
23635 #[inline(always)]
23636 fn inline_align(_context: fidl::encoding::Context) -> usize {
23637 8
23638 }
23639
23640 #[inline(always)]
23641 fn inline_size(_context: fidl::encoding::Context) -> usize {
23642 16
23643 }
23644 }
23645
23646 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncoderSettings, D>
23647 for &EncoderSettings
23648 {
23649 #[inline]
23650 unsafe fn encode(
23651 self,
23652 encoder: &mut fidl::encoding::Encoder<'_, D>,
23653 offset: usize,
23654 _depth: fidl::encoding::Depth,
23655 ) -> fidl::Result<()> {
23656 encoder.debug_check_bounds::<EncoderSettings>(offset);
23657 encoder.write_num::<u64>(self.ordinal(), offset);
23658 match self {
23659 EncoderSettings::Sbc(ref val) => {
23660 fidl::encoding::encode_in_envelope::<SbcEncoderSettings, D>(
23661 <SbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23662 encoder,
23663 offset + 8,
23664 _depth,
23665 )
23666 }
23667 EncoderSettings::Aac(ref val) => {
23668 fidl::encoding::encode_in_envelope::<AacEncoderSettings, D>(
23669 <AacEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23670 encoder,
23671 offset + 8,
23672 _depth,
23673 )
23674 }
23675 EncoderSettings::H264(ref val) => {
23676 fidl::encoding::encode_in_envelope::<H264EncoderSettings, D>(
23677 <H264EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23678 encoder,
23679 offset + 8,
23680 _depth,
23681 )
23682 }
23683 EncoderSettings::Hevc(ref val) => {
23684 fidl::encoding::encode_in_envelope::<HevcEncoderSettings, D>(
23685 <HevcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23686 encoder,
23687 offset + 8,
23688 _depth,
23689 )
23690 }
23691 EncoderSettings::Cvsd(ref val) => {
23692 fidl::encoding::encode_in_envelope::<CvsdEncoderSettings, D>(
23693 <CvsdEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23694 encoder,
23695 offset + 8,
23696 _depth,
23697 )
23698 }
23699 EncoderSettings::Lc3(ref val) => {
23700 fidl::encoding::encode_in_envelope::<Lc3EncoderSettings, D>(
23701 <Lc3EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23702 encoder,
23703 offset + 8,
23704 _depth,
23705 )
23706 }
23707 EncoderSettings::Msbc(ref val) => {
23708 fidl::encoding::encode_in_envelope::<MSbcEncoderSettings, D>(
23709 <MSbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23710 encoder,
23711 offset + 8,
23712 _depth,
23713 )
23714 }
23715 EncoderSettings::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23716 }
23717 }
23718 }
23719
23720 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncoderSettings {
23721 #[inline(always)]
23722 fn new_empty() -> Self {
23723 Self::__SourceBreaking { unknown_ordinal: 0 }
23724 }
23725
23726 #[inline]
23727 unsafe fn decode(
23728 &mut self,
23729 decoder: &mut fidl::encoding::Decoder<'_, D>,
23730 offset: usize,
23731 mut depth: fidl::encoding::Depth,
23732 ) -> fidl::Result<()> {
23733 decoder.debug_check_bounds::<Self>(offset);
23734 #[allow(unused_variables)]
23735 let next_out_of_line = decoder.next_out_of_line();
23736 let handles_before = decoder.remaining_handles();
23737 let (ordinal, inlined, num_bytes, num_handles) =
23738 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23739
23740 let member_inline_size = match ordinal {
23741 1 => {
23742 <SbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23743 }
23744 2 => {
23745 <AacEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23746 }
23747 3 => <H264EncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23748 decoder.context,
23749 ),
23750 4 => <HevcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23751 decoder.context,
23752 ),
23753 5 => <CvsdEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23754 decoder.context,
23755 ),
23756 6 => {
23757 <Lc3EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23758 }
23759 7 => <MSbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23760 decoder.context,
23761 ),
23762 0 => return Err(fidl::Error::UnknownUnionTag),
23763 _ => num_bytes as usize,
23764 };
23765
23766 if inlined != (member_inline_size <= 4) {
23767 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23768 }
23769 let _inner_offset;
23770 if inlined {
23771 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23772 _inner_offset = offset + 8;
23773 } else {
23774 depth.increment()?;
23775 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23776 }
23777 match ordinal {
23778 1 => {
23779 #[allow(irrefutable_let_patterns)]
23780 if let EncoderSettings::Sbc(_) = self {
23781 } else {
23783 *self = EncoderSettings::Sbc(fidl::new_empty!(SbcEncoderSettings, D));
23785 }
23786 #[allow(irrefutable_let_patterns)]
23787 if let EncoderSettings::Sbc(ref mut val) = self {
23788 fidl::decode!(SbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23789 } else {
23790 unreachable!()
23791 }
23792 }
23793 2 => {
23794 #[allow(irrefutable_let_patterns)]
23795 if let EncoderSettings::Aac(_) = self {
23796 } else {
23798 *self = EncoderSettings::Aac(fidl::new_empty!(AacEncoderSettings, D));
23800 }
23801 #[allow(irrefutable_let_patterns)]
23802 if let EncoderSettings::Aac(ref mut val) = self {
23803 fidl::decode!(AacEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23804 } else {
23805 unreachable!()
23806 }
23807 }
23808 3 => {
23809 #[allow(irrefutable_let_patterns)]
23810 if let EncoderSettings::H264(_) = self {
23811 } else {
23813 *self = EncoderSettings::H264(fidl::new_empty!(H264EncoderSettings, D));
23815 }
23816 #[allow(irrefutable_let_patterns)]
23817 if let EncoderSettings::H264(ref mut val) = self {
23818 fidl::decode!(H264EncoderSettings, D, val, decoder, _inner_offset, depth)?;
23819 } else {
23820 unreachable!()
23821 }
23822 }
23823 4 => {
23824 #[allow(irrefutable_let_patterns)]
23825 if let EncoderSettings::Hevc(_) = self {
23826 } else {
23828 *self = EncoderSettings::Hevc(fidl::new_empty!(HevcEncoderSettings, D));
23830 }
23831 #[allow(irrefutable_let_patterns)]
23832 if let EncoderSettings::Hevc(ref mut val) = self {
23833 fidl::decode!(HevcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23834 } else {
23835 unreachable!()
23836 }
23837 }
23838 5 => {
23839 #[allow(irrefutable_let_patterns)]
23840 if let EncoderSettings::Cvsd(_) = self {
23841 } else {
23843 *self = EncoderSettings::Cvsd(fidl::new_empty!(CvsdEncoderSettings, D));
23845 }
23846 #[allow(irrefutable_let_patterns)]
23847 if let EncoderSettings::Cvsd(ref mut val) = self {
23848 fidl::decode!(CvsdEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23849 } else {
23850 unreachable!()
23851 }
23852 }
23853 6 => {
23854 #[allow(irrefutable_let_patterns)]
23855 if let EncoderSettings::Lc3(_) = self {
23856 } else {
23858 *self = EncoderSettings::Lc3(fidl::new_empty!(Lc3EncoderSettings, D));
23860 }
23861 #[allow(irrefutable_let_patterns)]
23862 if let EncoderSettings::Lc3(ref mut val) = self {
23863 fidl::decode!(Lc3EncoderSettings, D, val, decoder, _inner_offset, depth)?;
23864 } else {
23865 unreachable!()
23866 }
23867 }
23868 7 => {
23869 #[allow(irrefutable_let_patterns)]
23870 if let EncoderSettings::Msbc(_) = self {
23871 } else {
23873 *self = EncoderSettings::Msbc(fidl::new_empty!(MSbcEncoderSettings, D));
23875 }
23876 #[allow(irrefutable_let_patterns)]
23877 if let EncoderSettings::Msbc(ref mut val) = self {
23878 fidl::decode!(MSbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23879 } else {
23880 unreachable!()
23881 }
23882 }
23883 #[allow(deprecated)]
23884 ordinal => {
23885 for _ in 0..num_handles {
23886 decoder.drop_next_handle()?;
23887 }
23888 *self = EncoderSettings::__SourceBreaking { unknown_ordinal: ordinal };
23889 }
23890 }
23891 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23892 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23893 }
23894 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23895 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23896 }
23897 Ok(())
23898 }
23899 }
23900
23901 impl fidl::encoding::ValueTypeMarker for MediumSpecificStreamType {
23902 type Borrowed<'a> = &'a Self;
23903 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23904 value
23905 }
23906 }
23907
23908 unsafe impl fidl::encoding::TypeMarker for MediumSpecificStreamType {
23909 type Owned = Self;
23910
23911 #[inline(always)]
23912 fn inline_align(_context: fidl::encoding::Context) -> usize {
23913 8
23914 }
23915
23916 #[inline(always)]
23917 fn inline_size(_context: fidl::encoding::Context) -> usize {
23918 16
23919 }
23920 }
23921
23922 unsafe impl<D: fidl::encoding::ResourceDialect>
23923 fidl::encoding::Encode<MediumSpecificStreamType, D> for &MediumSpecificStreamType
23924 {
23925 #[inline]
23926 unsafe fn encode(
23927 self,
23928 encoder: &mut fidl::encoding::Encoder<'_, D>,
23929 offset: usize,
23930 _depth: fidl::encoding::Depth,
23931 ) -> fidl::Result<()> {
23932 encoder.debug_check_bounds::<MediumSpecificStreamType>(offset);
23933 encoder.write_num::<u64>(self.ordinal(), offset);
23934 match self {
23935 MediumSpecificStreamType::Audio(ref val) => {
23936 fidl::encoding::encode_in_envelope::<AudioStreamType, D>(
23937 <AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
23938 encoder,
23939 offset + 8,
23940 _depth,
23941 )
23942 }
23943 MediumSpecificStreamType::Video(ref val) => {
23944 fidl::encoding::encode_in_envelope::<VideoStreamType, D>(
23945 <VideoStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
23946 encoder,
23947 offset + 8,
23948 _depth,
23949 )
23950 }
23951 MediumSpecificStreamType::Text(ref val) => {
23952 fidl::encoding::encode_in_envelope::<TextStreamType, D>(
23953 <TextStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
23954 encoder,
23955 offset + 8,
23956 _depth,
23957 )
23958 }
23959 MediumSpecificStreamType::Subpicture(ref val) => {
23960 fidl::encoding::encode_in_envelope::<SubpictureStreamType, D>(
23961 <SubpictureStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
23962 encoder,
23963 offset + 8,
23964 _depth,
23965 )
23966 }
23967 }
23968 }
23969 }
23970
23971 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
23972 for MediumSpecificStreamType
23973 {
23974 #[inline(always)]
23975 fn new_empty() -> Self {
23976 Self::Audio(fidl::new_empty!(AudioStreamType, D))
23977 }
23978
23979 #[inline]
23980 unsafe fn decode(
23981 &mut self,
23982 decoder: &mut fidl::encoding::Decoder<'_, D>,
23983 offset: usize,
23984 mut depth: fidl::encoding::Depth,
23985 ) -> fidl::Result<()> {
23986 decoder.debug_check_bounds::<Self>(offset);
23987 #[allow(unused_variables)]
23988 let next_out_of_line = decoder.next_out_of_line();
23989 let handles_before = decoder.remaining_handles();
23990 let (ordinal, inlined, num_bytes, num_handles) =
23991 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23992
23993 let member_inline_size = match ordinal {
23994 1 => <AudioStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23995 2 => <VideoStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23996 3 => <TextStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23997 4 => <SubpictureStreamType as fidl::encoding::TypeMarker>::inline_size(
23998 decoder.context,
23999 ),
24000 _ => return Err(fidl::Error::UnknownUnionTag),
24001 };
24002
24003 if inlined != (member_inline_size <= 4) {
24004 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24005 }
24006 let _inner_offset;
24007 if inlined {
24008 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24009 _inner_offset = offset + 8;
24010 } else {
24011 depth.increment()?;
24012 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24013 }
24014 match ordinal {
24015 1 => {
24016 #[allow(irrefutable_let_patterns)]
24017 if let MediumSpecificStreamType::Audio(_) = self {
24018 } else {
24020 *self =
24022 MediumSpecificStreamType::Audio(fidl::new_empty!(AudioStreamType, D));
24023 }
24024 #[allow(irrefutable_let_patterns)]
24025 if let MediumSpecificStreamType::Audio(ref mut val) = self {
24026 fidl::decode!(AudioStreamType, D, val, decoder, _inner_offset, depth)?;
24027 } else {
24028 unreachable!()
24029 }
24030 }
24031 2 => {
24032 #[allow(irrefutable_let_patterns)]
24033 if let MediumSpecificStreamType::Video(_) = self {
24034 } else {
24036 *self =
24038 MediumSpecificStreamType::Video(fidl::new_empty!(VideoStreamType, D));
24039 }
24040 #[allow(irrefutable_let_patterns)]
24041 if let MediumSpecificStreamType::Video(ref mut val) = self {
24042 fidl::decode!(VideoStreamType, D, val, decoder, _inner_offset, depth)?;
24043 } else {
24044 unreachable!()
24045 }
24046 }
24047 3 => {
24048 #[allow(irrefutable_let_patterns)]
24049 if let MediumSpecificStreamType::Text(_) = self {
24050 } else {
24052 *self = MediumSpecificStreamType::Text(fidl::new_empty!(TextStreamType, D));
24054 }
24055 #[allow(irrefutable_let_patterns)]
24056 if let MediumSpecificStreamType::Text(ref mut val) = self {
24057 fidl::decode!(TextStreamType, D, val, decoder, _inner_offset, depth)?;
24058 } else {
24059 unreachable!()
24060 }
24061 }
24062 4 => {
24063 #[allow(irrefutable_let_patterns)]
24064 if let MediumSpecificStreamType::Subpicture(_) = self {
24065 } else {
24067 *self = MediumSpecificStreamType::Subpicture(fidl::new_empty!(
24069 SubpictureStreamType,
24070 D
24071 ));
24072 }
24073 #[allow(irrefutable_let_patterns)]
24074 if let MediumSpecificStreamType::Subpicture(ref mut val) = self {
24075 fidl::decode!(SubpictureStreamType, D, val, decoder, _inner_offset, depth)?;
24076 } else {
24077 unreachable!()
24078 }
24079 }
24080 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24081 }
24082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24083 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24084 }
24085 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24086 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24087 }
24088 Ok(())
24089 }
24090 }
24091
24092 impl fidl::encoding::ValueTypeMarker for Usage {
24093 type Borrowed<'a> = &'a Self;
24094 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24095 value
24096 }
24097 }
24098
24099 unsafe impl fidl::encoding::TypeMarker for Usage {
24100 type Owned = Self;
24101
24102 #[inline(always)]
24103 fn inline_align(_context: fidl::encoding::Context) -> usize {
24104 8
24105 }
24106
24107 #[inline(always)]
24108 fn inline_size(_context: fidl::encoding::Context) -> usize {
24109 16
24110 }
24111 }
24112
24113 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage, D> for &Usage {
24114 #[inline]
24115 unsafe fn encode(
24116 self,
24117 encoder: &mut fidl::encoding::Encoder<'_, D>,
24118 offset: usize,
24119 _depth: fidl::encoding::Depth,
24120 ) -> fidl::Result<()> {
24121 encoder.debug_check_bounds::<Usage>(offset);
24122 encoder.write_num::<u64>(self.ordinal(), offset);
24123 match self {
24124 Usage::RenderUsage(ref val) => {
24125 fidl::encoding::encode_in_envelope::<AudioRenderUsage, D>(
24126 <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24127 encoder,
24128 offset + 8,
24129 _depth,
24130 )
24131 }
24132 Usage::CaptureUsage(ref val) => {
24133 fidl::encoding::encode_in_envelope::<AudioCaptureUsage, D>(
24134 <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24135 encoder,
24136 offset + 8,
24137 _depth,
24138 )
24139 }
24140 }
24141 }
24142 }
24143
24144 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage {
24145 #[inline(always)]
24146 fn new_empty() -> Self {
24147 Self::RenderUsage(fidl::new_empty!(AudioRenderUsage, D))
24148 }
24149
24150 #[inline]
24151 unsafe fn decode(
24152 &mut self,
24153 decoder: &mut fidl::encoding::Decoder<'_, D>,
24154 offset: usize,
24155 mut depth: fidl::encoding::Depth,
24156 ) -> fidl::Result<()> {
24157 decoder.debug_check_bounds::<Self>(offset);
24158 #[allow(unused_variables)]
24159 let next_out_of_line = decoder.next_out_of_line();
24160 let handles_before = decoder.remaining_handles();
24161 let (ordinal, inlined, num_bytes, num_handles) =
24162 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24163
24164 let member_inline_size = match ordinal {
24165 1 => <AudioRenderUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24166 2 => {
24167 <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24168 }
24169 _ => return Err(fidl::Error::UnknownUnionTag),
24170 };
24171
24172 if inlined != (member_inline_size <= 4) {
24173 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24174 }
24175 let _inner_offset;
24176 if inlined {
24177 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24178 _inner_offset = offset + 8;
24179 } else {
24180 depth.increment()?;
24181 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24182 }
24183 match ordinal {
24184 1 => {
24185 #[allow(irrefutable_let_patterns)]
24186 if let Usage::RenderUsage(_) = self {
24187 } else {
24189 *self = Usage::RenderUsage(fidl::new_empty!(AudioRenderUsage, D));
24191 }
24192 #[allow(irrefutable_let_patterns)]
24193 if let Usage::RenderUsage(ref mut val) = self {
24194 fidl::decode!(AudioRenderUsage, D, val, decoder, _inner_offset, depth)?;
24195 } else {
24196 unreachable!()
24197 }
24198 }
24199 2 => {
24200 #[allow(irrefutable_let_patterns)]
24201 if let Usage::CaptureUsage(_) = self {
24202 } else {
24204 *self = Usage::CaptureUsage(fidl::new_empty!(AudioCaptureUsage, D));
24206 }
24207 #[allow(irrefutable_let_patterns)]
24208 if let Usage::CaptureUsage(ref mut val) = self {
24209 fidl::decode!(AudioCaptureUsage, D, val, decoder, _inner_offset, depth)?;
24210 } else {
24211 unreachable!()
24212 }
24213 }
24214 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24215 }
24216 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24217 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24218 }
24219 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24220 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24221 }
24222 Ok(())
24223 }
24224 }
24225
24226 impl fidl::encoding::ValueTypeMarker for Usage2 {
24227 type Borrowed<'a> = &'a Self;
24228 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24229 value
24230 }
24231 }
24232
24233 unsafe impl fidl::encoding::TypeMarker for Usage2 {
24234 type Owned = Self;
24235
24236 #[inline(always)]
24237 fn inline_align(_context: fidl::encoding::Context) -> usize {
24238 8
24239 }
24240
24241 #[inline(always)]
24242 fn inline_size(_context: fidl::encoding::Context) -> usize {
24243 16
24244 }
24245 }
24246
24247 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage2, D> for &Usage2 {
24248 #[inline]
24249 unsafe fn encode(
24250 self,
24251 encoder: &mut fidl::encoding::Encoder<'_, D>,
24252 offset: usize,
24253 _depth: fidl::encoding::Depth,
24254 ) -> fidl::Result<()> {
24255 encoder.debug_check_bounds::<Usage2>(offset);
24256 encoder.write_num::<u64>(self.ordinal(), offset);
24257 match self {
24258 Usage2::RenderUsage(ref val) => {
24259 fidl::encoding::encode_in_envelope::<AudioRenderUsage2, D>(
24260 <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24261 encoder,
24262 offset + 8,
24263 _depth,
24264 )
24265 }
24266 Usage2::CaptureUsage(ref val) => {
24267 fidl::encoding::encode_in_envelope::<AudioCaptureUsage2, D>(
24268 <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24269 encoder,
24270 offset + 8,
24271 _depth,
24272 )
24273 }
24274 Usage2::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24275 }
24276 }
24277 }
24278
24279 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage2 {
24280 #[inline(always)]
24281 fn new_empty() -> Self {
24282 Self::__SourceBreaking { unknown_ordinal: 0 }
24283 }
24284
24285 #[inline]
24286 unsafe fn decode(
24287 &mut self,
24288 decoder: &mut fidl::encoding::Decoder<'_, D>,
24289 offset: usize,
24290 mut depth: fidl::encoding::Depth,
24291 ) -> fidl::Result<()> {
24292 decoder.debug_check_bounds::<Self>(offset);
24293 #[allow(unused_variables)]
24294 let next_out_of_line = decoder.next_out_of_line();
24295 let handles_before = decoder.remaining_handles();
24296 let (ordinal, inlined, num_bytes, num_handles) =
24297 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24298
24299 let member_inline_size = match ordinal {
24300 1 => {
24301 <AudioRenderUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24302 }
24303 2 => {
24304 <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24305 }
24306 0 => return Err(fidl::Error::UnknownUnionTag),
24307 _ => num_bytes as usize,
24308 };
24309
24310 if inlined != (member_inline_size <= 4) {
24311 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24312 }
24313 let _inner_offset;
24314 if inlined {
24315 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24316 _inner_offset = offset + 8;
24317 } else {
24318 depth.increment()?;
24319 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24320 }
24321 match ordinal {
24322 1 => {
24323 #[allow(irrefutable_let_patterns)]
24324 if let Usage2::RenderUsage(_) = self {
24325 } else {
24327 *self = Usage2::RenderUsage(fidl::new_empty!(AudioRenderUsage2, D));
24329 }
24330 #[allow(irrefutable_let_patterns)]
24331 if let Usage2::RenderUsage(ref mut val) = self {
24332 fidl::decode!(AudioRenderUsage2, D, val, decoder, _inner_offset, depth)?;
24333 } else {
24334 unreachable!()
24335 }
24336 }
24337 2 => {
24338 #[allow(irrefutable_let_patterns)]
24339 if let Usage2::CaptureUsage(_) = self {
24340 } else {
24342 *self = Usage2::CaptureUsage(fidl::new_empty!(AudioCaptureUsage2, D));
24344 }
24345 #[allow(irrefutable_let_patterns)]
24346 if let Usage2::CaptureUsage(ref mut val) = self {
24347 fidl::decode!(AudioCaptureUsage2, D, val, decoder, _inner_offset, depth)?;
24348 } else {
24349 unreachable!()
24350 }
24351 }
24352 #[allow(deprecated)]
24353 ordinal => {
24354 for _ in 0..num_handles {
24355 decoder.drop_next_handle()?;
24356 }
24357 *self = Usage2::__SourceBreaking { unknown_ordinal: ordinal };
24358 }
24359 }
24360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24362 }
24363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24365 }
24366 Ok(())
24367 }
24368 }
24369
24370 impl fidl::encoding::ValueTypeMarker for UsageState {
24371 type Borrowed<'a> = &'a Self;
24372 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24373 value
24374 }
24375 }
24376
24377 unsafe impl fidl::encoding::TypeMarker for UsageState {
24378 type Owned = Self;
24379
24380 #[inline(always)]
24381 fn inline_align(_context: fidl::encoding::Context) -> usize {
24382 8
24383 }
24384
24385 #[inline(always)]
24386 fn inline_size(_context: fidl::encoding::Context) -> usize {
24387 16
24388 }
24389 }
24390
24391 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageState, D>
24392 for &UsageState
24393 {
24394 #[inline]
24395 unsafe fn encode(
24396 self,
24397 encoder: &mut fidl::encoding::Encoder<'_, D>,
24398 offset: usize,
24399 _depth: fidl::encoding::Depth,
24400 ) -> fidl::Result<()> {
24401 encoder.debug_check_bounds::<UsageState>(offset);
24402 encoder.write_num::<u64>(self.ordinal(), offset);
24403 match self {
24404 UsageState::Unadjusted(ref val) => {
24405 fidl::encoding::encode_in_envelope::<UsageStateUnadjusted, D>(
24406 <UsageStateUnadjusted as fidl::encoding::ValueTypeMarker>::borrow(val),
24407 encoder,
24408 offset + 8,
24409 _depth,
24410 )
24411 }
24412 UsageState::Ducked(ref val) => {
24413 fidl::encoding::encode_in_envelope::<UsageStateDucked, D>(
24414 <UsageStateDucked as fidl::encoding::ValueTypeMarker>::borrow(val),
24415 encoder,
24416 offset + 8,
24417 _depth,
24418 )
24419 }
24420 UsageState::Muted(ref val) => {
24421 fidl::encoding::encode_in_envelope::<UsageStateMuted, D>(
24422 <UsageStateMuted as fidl::encoding::ValueTypeMarker>::borrow(val),
24423 encoder,
24424 offset + 8,
24425 _depth,
24426 )
24427 }
24428 UsageState::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24429 }
24430 }
24431 }
24432
24433 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageState {
24434 #[inline(always)]
24435 fn new_empty() -> Self {
24436 Self::__SourceBreaking { unknown_ordinal: 0 }
24437 }
24438
24439 #[inline]
24440 unsafe fn decode(
24441 &mut self,
24442 decoder: &mut fidl::encoding::Decoder<'_, D>,
24443 offset: usize,
24444 mut depth: fidl::encoding::Depth,
24445 ) -> fidl::Result<()> {
24446 decoder.debug_check_bounds::<Self>(offset);
24447 #[allow(unused_variables)]
24448 let next_out_of_line = decoder.next_out_of_line();
24449 let handles_before = decoder.remaining_handles();
24450 let (ordinal, inlined, num_bytes, num_handles) =
24451 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24452
24453 let member_inline_size = match ordinal {
24454 1 => <UsageStateUnadjusted as fidl::encoding::TypeMarker>::inline_size(
24455 decoder.context,
24456 ),
24457 2 => <UsageStateDucked as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24458 3 => <UsageStateMuted as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24459 0 => return Err(fidl::Error::UnknownUnionTag),
24460 _ => num_bytes as usize,
24461 };
24462
24463 if inlined != (member_inline_size <= 4) {
24464 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24465 }
24466 let _inner_offset;
24467 if inlined {
24468 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24469 _inner_offset = offset + 8;
24470 } else {
24471 depth.increment()?;
24472 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24473 }
24474 match ordinal {
24475 1 => {
24476 #[allow(irrefutable_let_patterns)]
24477 if let UsageState::Unadjusted(_) = self {
24478 } else {
24480 *self = UsageState::Unadjusted(fidl::new_empty!(UsageStateUnadjusted, D));
24482 }
24483 #[allow(irrefutable_let_patterns)]
24484 if let UsageState::Unadjusted(ref mut val) = self {
24485 fidl::decode!(UsageStateUnadjusted, D, val, decoder, _inner_offset, depth)?;
24486 } else {
24487 unreachable!()
24488 }
24489 }
24490 2 => {
24491 #[allow(irrefutable_let_patterns)]
24492 if let UsageState::Ducked(_) = self {
24493 } else {
24495 *self = UsageState::Ducked(fidl::new_empty!(UsageStateDucked, D));
24497 }
24498 #[allow(irrefutable_let_patterns)]
24499 if let UsageState::Ducked(ref mut val) = self {
24500 fidl::decode!(UsageStateDucked, D, val, decoder, _inner_offset, depth)?;
24501 } else {
24502 unreachable!()
24503 }
24504 }
24505 3 => {
24506 #[allow(irrefutable_let_patterns)]
24507 if let UsageState::Muted(_) = self {
24508 } else {
24510 *self = UsageState::Muted(fidl::new_empty!(UsageStateMuted, D));
24512 }
24513 #[allow(irrefutable_let_patterns)]
24514 if let UsageState::Muted(ref mut val) = self {
24515 fidl::decode!(UsageStateMuted, D, val, decoder, _inner_offset, depth)?;
24516 } else {
24517 unreachable!()
24518 }
24519 }
24520 #[allow(deprecated)]
24521 ordinal => {
24522 for _ in 0..num_handles {
24523 decoder.drop_next_handle()?;
24524 }
24525 *self = UsageState::__SourceBreaking { unknown_ordinal: ordinal };
24526 }
24527 }
24528 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24529 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24530 }
24531 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24532 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24533 }
24534 Ok(())
24535 }
24536 }
24537
24538 impl fidl::encoding::ValueTypeMarker for Value {
24539 type Borrowed<'a> = &'a Self;
24540 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24541 value
24542 }
24543 }
24544
24545 unsafe impl fidl::encoding::TypeMarker for Value {
24546 type Owned = Self;
24547
24548 #[inline(always)]
24549 fn inline_align(_context: fidl::encoding::Context) -> usize {
24550 8
24551 }
24552
24553 #[inline(always)]
24554 fn inline_size(_context: fidl::encoding::Context) -> usize {
24555 16
24556 }
24557 }
24558
24559 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Value, D> for &Value {
24560 #[inline]
24561 unsafe fn encode(
24562 self,
24563 encoder: &mut fidl::encoding::Encoder<'_, D>,
24564 offset: usize,
24565 _depth: fidl::encoding::Depth,
24566 ) -> fidl::Result<()> {
24567 encoder.debug_check_bounds::<Value>(offset);
24568 encoder.write_num::<u64>(self.ordinal(), offset);
24569 match self {
24570 Value::BoolValue(ref val) => {
24571 fidl::encoding::encode_in_envelope::<bool, D>(
24572 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
24573 encoder, offset + 8, _depth
24574 )
24575 }
24576 Value::Uint64Value(ref val) => {
24577 fidl::encoding::encode_in_envelope::<u64, D>(
24578 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24579 encoder, offset + 8, _depth
24580 )
24581 }
24582 Value::Int64Value(ref val) => {
24583 fidl::encoding::encode_in_envelope::<i64, D>(
24584 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24585 encoder, offset + 8, _depth
24586 )
24587 }
24588 Value::StringValue(ref val) => {
24589 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, D>(
24590 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
24591 encoder, offset + 8, _depth
24592 )
24593 }
24594 Value::BytesValue(ref val) => {
24595 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
24596 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
24597 encoder, offset + 8, _depth
24598 )
24599 }
24600 }
24601 }
24602 }
24603
24604 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Value {
24605 #[inline(always)]
24606 fn new_empty() -> Self {
24607 Self::BoolValue(fidl::new_empty!(bool, D))
24608 }
24609
24610 #[inline]
24611 unsafe fn decode(
24612 &mut self,
24613 decoder: &mut fidl::encoding::Decoder<'_, D>,
24614 offset: usize,
24615 mut depth: fidl::encoding::Depth,
24616 ) -> fidl::Result<()> {
24617 decoder.debug_check_bounds::<Self>(offset);
24618 #[allow(unused_variables)]
24619 let next_out_of_line = decoder.next_out_of_line();
24620 let handles_before = decoder.remaining_handles();
24621 let (ordinal, inlined, num_bytes, num_handles) =
24622 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24623
24624 let member_inline_size = match ordinal {
24625 1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24626 2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24627 3 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24628 4 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
24629 decoder.context,
24630 ),
24631 5 => {
24632 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
24633 decoder.context,
24634 )
24635 }
24636 _ => return Err(fidl::Error::UnknownUnionTag),
24637 };
24638
24639 if inlined != (member_inline_size <= 4) {
24640 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24641 }
24642 let _inner_offset;
24643 if inlined {
24644 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24645 _inner_offset = offset + 8;
24646 } else {
24647 depth.increment()?;
24648 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24649 }
24650 match ordinal {
24651 1 => {
24652 #[allow(irrefutable_let_patterns)]
24653 if let Value::BoolValue(_) = self {
24654 } else {
24656 *self = Value::BoolValue(fidl::new_empty!(bool, D));
24658 }
24659 #[allow(irrefutable_let_patterns)]
24660 if let Value::BoolValue(ref mut val) = self {
24661 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
24662 } else {
24663 unreachable!()
24664 }
24665 }
24666 2 => {
24667 #[allow(irrefutable_let_patterns)]
24668 if let Value::Uint64Value(_) = self {
24669 } else {
24671 *self = Value::Uint64Value(fidl::new_empty!(u64, D));
24673 }
24674 #[allow(irrefutable_let_patterns)]
24675 if let Value::Uint64Value(ref mut val) = self {
24676 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
24677 } else {
24678 unreachable!()
24679 }
24680 }
24681 3 => {
24682 #[allow(irrefutable_let_patterns)]
24683 if let Value::Int64Value(_) = self {
24684 } else {
24686 *self = Value::Int64Value(fidl::new_empty!(i64, D));
24688 }
24689 #[allow(irrefutable_let_patterns)]
24690 if let Value::Int64Value(ref mut val) = self {
24691 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
24692 } else {
24693 unreachable!()
24694 }
24695 }
24696 4 => {
24697 #[allow(irrefutable_let_patterns)]
24698 if let Value::StringValue(_) = self {
24699 } else {
24701 *self = Value::StringValue(fidl::new_empty!(
24703 fidl::encoding::UnboundedString,
24704 D
24705 ));
24706 }
24707 #[allow(irrefutable_let_patterns)]
24708 if let Value::StringValue(ref mut val) = self {
24709 fidl::decode!(
24710 fidl::encoding::UnboundedString,
24711 D,
24712 val,
24713 decoder,
24714 _inner_offset,
24715 depth
24716 )?;
24717 } else {
24718 unreachable!()
24719 }
24720 }
24721 5 => {
24722 #[allow(irrefutable_let_patterns)]
24723 if let Value::BytesValue(_) = self {
24724 } else {
24726 *self = Value::BytesValue(fidl::new_empty!(
24728 fidl::encoding::UnboundedVector<u8>,
24729 D
24730 ));
24731 }
24732 #[allow(irrefutable_let_patterns)]
24733 if let Value::BytesValue(ref mut val) = self {
24734 fidl::decode!(
24735 fidl::encoding::UnboundedVector<u8>,
24736 D,
24737 val,
24738 decoder,
24739 _inner_offset,
24740 depth
24741 )?;
24742 } else {
24743 unreachable!()
24744 }
24745 }
24746 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24747 }
24748 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24749 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24750 }
24751 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24752 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24753 }
24754 Ok(())
24755 }
24756 }
24757
24758 impl fidl::encoding::ValueTypeMarker for VideoCompressedFormat {
24759 type Borrowed<'a> = &'a Self;
24760 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24761 value
24762 }
24763 }
24764
24765 unsafe impl fidl::encoding::TypeMarker for VideoCompressedFormat {
24766 type Owned = Self;
24767
24768 #[inline(always)]
24769 fn inline_align(_context: fidl::encoding::Context) -> usize {
24770 8
24771 }
24772
24773 #[inline(always)]
24774 fn inline_size(_context: fidl::encoding::Context) -> usize {
24775 16
24776 }
24777 }
24778
24779 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoCompressedFormat, D>
24780 for &VideoCompressedFormat
24781 {
24782 #[inline]
24783 unsafe fn encode(
24784 self,
24785 encoder: &mut fidl::encoding::Encoder<'_, D>,
24786 offset: usize,
24787 _depth: fidl::encoding::Depth,
24788 ) -> fidl::Result<()> {
24789 encoder.debug_check_bounds::<VideoCompressedFormat>(offset);
24790 encoder.write_num::<u64>(self.ordinal(), offset);
24791 match self {
24792 VideoCompressedFormat::TempFieldTodoRemove(ref val) => {
24793 fidl::encoding::encode_in_envelope::<u32, D>(
24794 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
24795 encoder,
24796 offset + 8,
24797 _depth,
24798 )
24799 }
24800 }
24801 }
24802 }
24803
24804 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoCompressedFormat {
24805 #[inline(always)]
24806 fn new_empty() -> Self {
24807 Self::TempFieldTodoRemove(fidl::new_empty!(u32, D))
24808 }
24809
24810 #[inline]
24811 unsafe fn decode(
24812 &mut self,
24813 decoder: &mut fidl::encoding::Decoder<'_, D>,
24814 offset: usize,
24815 mut depth: fidl::encoding::Depth,
24816 ) -> fidl::Result<()> {
24817 decoder.debug_check_bounds::<Self>(offset);
24818 #[allow(unused_variables)]
24819 let next_out_of_line = decoder.next_out_of_line();
24820 let handles_before = decoder.remaining_handles();
24821 let (ordinal, inlined, num_bytes, num_handles) =
24822 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24823
24824 let member_inline_size = match ordinal {
24825 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24826 _ => return Err(fidl::Error::UnknownUnionTag),
24827 };
24828
24829 if inlined != (member_inline_size <= 4) {
24830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24831 }
24832 let _inner_offset;
24833 if inlined {
24834 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24835 _inner_offset = offset + 8;
24836 } else {
24837 depth.increment()?;
24838 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24839 }
24840 match ordinal {
24841 1 => {
24842 #[allow(irrefutable_let_patterns)]
24843 if let VideoCompressedFormat::TempFieldTodoRemove(_) = self {
24844 } else {
24846 *self =
24848 VideoCompressedFormat::TempFieldTodoRemove(fidl::new_empty!(u32, D));
24849 }
24850 #[allow(irrefutable_let_patterns)]
24851 if let VideoCompressedFormat::TempFieldTodoRemove(ref mut val) = self {
24852 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
24853 } else {
24854 unreachable!()
24855 }
24856 }
24857 ordinal => panic!("unexpected ordinal {:?}", ordinal),
24858 }
24859 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24860 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24861 }
24862 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24863 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24864 }
24865 Ok(())
24866 }
24867 }
24868
24869 impl fidl::encoding::ValueTypeMarker for VideoFormat {
24870 type Borrowed<'a> = &'a Self;
24871 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24872 value
24873 }
24874 }
24875
24876 unsafe impl fidl::encoding::TypeMarker for VideoFormat {
24877 type Owned = Self;
24878
24879 #[inline(always)]
24880 fn inline_align(_context: fidl::encoding::Context) -> usize {
24881 8
24882 }
24883
24884 #[inline(always)]
24885 fn inline_size(_context: fidl::encoding::Context) -> usize {
24886 16
24887 }
24888 }
24889
24890 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoFormat, D>
24891 for &VideoFormat
24892 {
24893 #[inline]
24894 unsafe fn encode(
24895 self,
24896 encoder: &mut fidl::encoding::Encoder<'_, D>,
24897 offset: usize,
24898 _depth: fidl::encoding::Depth,
24899 ) -> fidl::Result<()> {
24900 encoder.debug_check_bounds::<VideoFormat>(offset);
24901 encoder.write_num::<u64>(self.ordinal(), offset);
24902 match self {
24903 VideoFormat::Compressed(ref val) => {
24904 fidl::encoding::encode_in_envelope::<VideoCompressedFormat, D>(
24905 <VideoCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
24906 encoder,
24907 offset + 8,
24908 _depth,
24909 )
24910 }
24911 VideoFormat::Uncompressed(ref val) => {
24912 fidl::encoding::encode_in_envelope::<VideoUncompressedFormat, D>(
24913 <VideoUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
24914 encoder,
24915 offset + 8,
24916 _depth,
24917 )
24918 }
24919 }
24920 }
24921 }
24922
24923 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoFormat {
24924 #[inline(always)]
24925 fn new_empty() -> Self {
24926 Self::Compressed(fidl::new_empty!(VideoCompressedFormat, D))
24927 }
24928
24929 #[inline]
24930 unsafe fn decode(
24931 &mut self,
24932 decoder: &mut fidl::encoding::Decoder<'_, D>,
24933 offset: usize,
24934 mut depth: fidl::encoding::Depth,
24935 ) -> fidl::Result<()> {
24936 decoder.debug_check_bounds::<Self>(offset);
24937 #[allow(unused_variables)]
24938 let next_out_of_line = decoder.next_out_of_line();
24939 let handles_before = decoder.remaining_handles();
24940 let (ordinal, inlined, num_bytes, num_handles) =
24941 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24942
24943 let member_inline_size = match ordinal {
24944 1 => <VideoCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
24945 decoder.context,
24946 ),
24947 2 => <VideoUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
24948 decoder.context,
24949 ),
24950 _ => return Err(fidl::Error::UnknownUnionTag),
24951 };
24952
24953 if inlined != (member_inline_size <= 4) {
24954 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24955 }
24956 let _inner_offset;
24957 if inlined {
24958 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24959 _inner_offset = offset + 8;
24960 } else {
24961 depth.increment()?;
24962 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24963 }
24964 match ordinal {
24965 1 => {
24966 #[allow(irrefutable_let_patterns)]
24967 if let VideoFormat::Compressed(_) = self {
24968 } else {
24970 *self = VideoFormat::Compressed(fidl::new_empty!(VideoCompressedFormat, D));
24972 }
24973 #[allow(irrefutable_let_patterns)]
24974 if let VideoFormat::Compressed(ref mut val) = self {
24975 fidl::decode!(
24976 VideoCompressedFormat,
24977 D,
24978 val,
24979 decoder,
24980 _inner_offset,
24981 depth
24982 )?;
24983 } else {
24984 unreachable!()
24985 }
24986 }
24987 2 => {
24988 #[allow(irrefutable_let_patterns)]
24989 if let VideoFormat::Uncompressed(_) = self {
24990 } else {
24992 *self =
24994 VideoFormat::Uncompressed(fidl::new_empty!(VideoUncompressedFormat, D));
24995 }
24996 #[allow(irrefutable_let_patterns)]
24997 if let VideoFormat::Uncompressed(ref mut val) = self {
24998 fidl::decode!(
24999 VideoUncompressedFormat,
25000 D,
25001 val,
25002 decoder,
25003 _inner_offset,
25004 depth
25005 )?;
25006 } else {
25007 unreachable!()
25008 }
25009 }
25010 ordinal => panic!("unexpected ordinal {:?}", ordinal),
25011 }
25012 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25014 }
25015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25017 }
25018 Ok(())
25019 }
25020 }
25021}