fidl_fuchsia_media__common/
fidl_fuchsia_media__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// An identifier for compression types.
12pub type CompressionType = String;
13
14pub type EncryptionScheme = String;
15
16pub type InitVector = Vec<u8>;
17
18pub type KeyId = Vec<u8>;
19
20/// Audio encodings.
21pub 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
65/// The maximum number of frames that may be contained within a single StreamPacket.
66pub 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
76/// A reasonable upper-bound for the maximum number of render or capture usages. Use this value in
77/// FIDL APIs (e.g. for max vector size), instead of RENDER_USAGE2_COUNT or CAPTURE_USAGE2_COUNT
78/// directly. This way, an increase in these consts will not cause an ABI-breaking change.
79pub 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
105/// The title of the source of the media, e.g. a player, streaming service, or
106/// website.
107pub const METADATA_SOURCE_TITLE: &str = "fuchsia.media.source_title";
108
109/// Permitted ranges for AudioRenderer and AudioCapturer
110pub const MIN_PCM_CHANNEL_COUNT: u32 = 1;
111
112pub const MIN_PCM_FRAMES_PER_SECOND: u32 = 1000;
113
114/// When used as a `StreamPacket.pts` value, indicates that the packet has no
115/// specific presentation timestamp. The effective presentation time of such a
116/// packet depends on the context in which the `StreamPacket` is used.
117pub const NO_TIMESTAMP: i64 = 9223372036854775807;
118
119pub const RENDER_USAGE2_COUNT: u8 = 6;
120
121pub const RENDER_USAGE_COUNT: u8 = 5;
122
123/// Indicates a discontinuity in an otherwise continuous-in-time sequence of
124/// packets. The precise semantics of this flag depend on the context in which
125/// the `StreamPacket` is used.
126pub const STREAM_PACKET_FLAG_DISCONTINUITY: u32 = 4;
127
128/// Indicates that all other packets in the stream can be understood without
129/// reference to this packet. This is typically used in compressed streams to
130/// identify packets containing frames that may be discarded without affecting
131/// other frames.
132pub const STREAM_PACKET_FLAG_DROPPABLE: u32 = 2;
133
134/// Indicates that the packet can be understood without reference to other
135/// packets in the stream. This is typically used in compressed streams to
136/// identify packets that contain key frames.
137pub const STREAM_PACKET_FLAG_KEY_FRAME: u32 = 1;
138
139/// Video encodings.
140pub 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    /// Flags passed to `AudioConsumer.Start`.
160    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
161    pub struct AudioConsumerStartFlags: u32 {
162        /// Indicates that latency should be kept as low as possible.
163        const LOW_LATENCY = 1;
164        /// Indicates that the timing of packet delivery is determined by an external process rather
165        /// than being demand-based. When this flag is set, the service should expect underflow or
166        /// overflow due to a mismatch between packet arrival rate and presentation rate. When this
167        /// flag is not set, packets arrive on demand.
168        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    /// MPEG-2 Low Complexity
200    Mpeg2AacLc = 0,
201    /// MPEG-4 Low Complexity
202    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/// Variable bit rate modes. The actual resulting bitrate
245/// varies based on input signal and other encoding settings.
246///
247/// See https://wiki.hydrogenaud.io/index.php?title=Fraunhofer_FDK_AAC#Bitrate_Modes
248#[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/// Usages annotating the purpose of the stream being used to capture audio. The
303/// AudioCaptureUsage is used by audio policy to dictate how audio streams
304/// interact with each other.
305#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
306#[repr(u32)]
307pub enum AudioCaptureUsage {
308    /// Stream is used to capture audio while in the background. These streams
309    /// may be active at any the time and are considered privileged.
310    /// Example: Listening for Hotwords
311    Background = 0,
312    /// Stream is intended to be used for normal capture functionality. Streams
313    /// that are used for audio capture while the stream creator is in the
314    /// foreground should use this.
315    /// Example: Voice Recorder
316    Foreground = 1,
317    /// Stream is for interaction with a system agent. This should only be used
318    /// once a user has signalled their intent to have the interaction with an
319    /// interested party.
320    /// Examples: Assistant, Siri, Alexa
321    SystemAgent = 2,
322    /// Stream is intended to be used for some form of real time user to user
323    /// communication. Voice/Video chat should use this.
324    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/// Usages annotating the purpose of the stream being used to capture audio. The
346/// AudioCaptureUsage is used by audio policy to dictate how audio streams
347/// interact with each other.
348#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
349pub enum AudioCaptureUsage2 {
350    /// Stream is used to capture audio while in the background. These streams may be active at
351    /// any the time and are considered privileged.
352    /// Example: Listening for Hotwords
353    Background,
354    /// Stream is intended to be used for normal capture functionality. Streams that are used for
355    /// audio capture while the stream creator is in the foreground should use this.
356    /// Example: Voice Recorder
357    Foreground,
358    /// Stream is for interaction with a system agent. This should only be used once a user has
359    /// signalled their intent to have the interaction with an interested party.
360    /// Examples: Assistant, Siri, Alexa
361    SystemAgent,
362    /// Stream is intended to be used for some form of real time user to user communication.
363    /// Voice/Video chat should use this.
364    Communication,
365    #[doc(hidden)]
366    __SourceBreaking { unknown_ordinal: u32 },
367}
368
369/// Pattern that matches an unknown `AudioCaptureUsage2` member.
370#[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/// AudioChannelId
426///
427/// Used in specifying which audio channel is for which speaker location / type.
428///
429/// TODO(dustingreen): Do we need more channel IDs than this?
430#[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/// AudioPcmMode
499#[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/// Usage annotating the purpose of the stream being used to render audio.
525/// An AudioRenderer's usage cannot be changed after creation. The
526/// AudioRenderUsage is used by audio policy to dictate how audio streams
527/// interact with each other.
528#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
529#[repr(u32)]
530pub enum AudioRenderUsage {
531    /// Stream is intended to be used for ambient or background sound. Streams
532    /// that can be interrupted without consequence should use this.
533    Background = 0,
534    /// Stream is intended to be used for normal functionality. Streams that
535    /// are part of normal functionality should use this.
536    Media = 1,
537    /// Stream is intended to interrupt any ongoing function of the device.
538    /// Streams that are used for interruptions like notifications should use
539    /// this.
540    Interruption = 2,
541    /// Stream is for interaction with a system agent. This should be used
542    /// in response to a user initiated trigger.
543    SystemAgent = 3,
544    /// Stream is intended to be used for some form of real time user to user
545    /// communication. Voice/Video chat should use this.
546    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/// Usage annotating the purpose of the stream being used to render audio. An AudioRenderer's
569/// usage cannot be changed after creation. The AudioRenderUsage2 value is used by audio policy
570/// to dictate how audio streams interact with each other. This enum expands the original (strict)
571/// enum |AudioRenderUsage| with additional stream types.
572#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
573pub enum AudioRenderUsage2 {
574    /// Stream is intended to be used for ambient or background sound. Streams
575    /// that can be interrupted without consequence should use this.
576    Background,
577    /// Stream is intended to be used for normal functionality. Streams that
578    /// are part of normal functionality should use this.
579    Media,
580    /// Stream is intended to interrupt any ongoing function of the device.
581    /// Streams that are used for interruptions like notifications should use
582    /// this.
583    Interruption,
584    /// Stream is for interaction with a system agent. This should be used
585    /// in response to a user initiated trigger.
586    SystemAgent,
587    /// Stream is intended to be used for some form of real time user to user
588    /// communication. Voice/Video chat should use this.
589    Communication,
590    /// Stream is intended to be used for accessibility or other non-system-
591    /// agent speech output, such as screen reader TTS.
592    Accessibility,
593    #[doc(hidden)]
594    __SourceBreaking { unknown_ordinal: u32 },
595}
596
597/// Pattern that matches an unknown `AudioRenderUsage2` member.
598#[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/// Enumerates the supported audio sample formats.
660#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
661#[repr(u32)]
662pub enum AudioSampleFormat {
663    /// 8-bit unsigned samples, sample size 1 byte.
664    Unsigned8 = 1,
665    /// 16-bit signed samples, host-endian, sample size 2 bytes.
666    Signed16 = 2,
667    /// 24-bit signed samples in 32 bits, host-endian, sample size 4 bytes.
668    Signed24In32 = 3,
669    /// 32-bit floating-point samples, sample size 4 bytes.
670    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    /// Mix the streams.
694    None,
695    /// Apply a gain to duck the volume of one of the streams. (-14.0db)
696    Duck,
697    /// Apply a gain to mute one of the streams. (-160.0db)
698    Mute,
699    #[doc(hidden)]
700    __SourceBreaking { unknown_ordinal: u32 },
701}
702
703/// Pattern that matches an unknown `Behavior` member.
704#[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/// A list of permitted codec profiles. This list should be flexible since codecs can and will be added
757/// in the future. This can contain both video and audio profiles if needed.
758#[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/// Pattern that matches an unknown `CodecProfile` member.
787#[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/// Pattern that matches an unknown `Lc3FrameDuration` member.
930#[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/// StreamError
1080///
1081/// This error code encapsulates various errors that might emanate from a
1082/// StreamProcessor server. It can be sent either as an OnStreamFailed event or
1083/// as an epitaph for the channel.
1084#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1085#[repr(u32)]
1086pub enum StreamError {
1087    /// An internal error with an unspecified reason.
1088    Unknown = 1,
1089    /// The client provided invalid input format details.
1090    InvalidInputFormatDetails = 2,
1091    /// The server received buffers that are not suitable for the operation to
1092    /// be performed. An example of this would be if a Decoder received output
1093    /// buffers that are too small to decode a frame into.
1094    IncompatibleBuffersProvided = 3,
1095    /// Processing of input EOS (end of stream) failed, so the stream failed.
1096    /// Currently this can occur if a core codec watchdog fires while processing
1097    /// EOS.
1098    EosProcessing = 4,
1099    /// An internal decoder error with an unspecified reason.
1100    DecoderUnknown = 16777217,
1101    /// Input data that can't be parsed.  Only some parsing problems/errors are
1102    /// reported this way.  Corrupt input data may be reported as other
1103    /// StreamError, or may not cause a StreamError.
1104    DecoderDataParsing = 16777218,
1105    /// An internal encoder error with an unspecified reason.
1106    EncoderUnknown = 33554433,
1107    /// An internal decryptor error with an unspecified reason.
1108    DecryptorUnknown = 50331649,
1109    /// The requested KeyId is not available for use by the Decryptor. The
1110    /// client may try again later if that key becomes available.
1111    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    /// Bits per second
1162    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/// AAC inside ADTS
1178#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1179pub struct AacTransportAdts;
1180
1181impl fidl::Persistable for AacTransportAdts {}
1182
1183/// AAC inside LATM
1184#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1185pub struct AacTransportLatm {
1186    /// Whether MuxConfiguration stream element is present
1187    pub mux_config_present: bool,
1188}
1189
1190impl fidl::Persistable for AacTransportLatm {}
1191
1192/// Raw AAC access units.
1193#[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/// Describes the type of an audio elementary stream.
1611#[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/// Describes the compression applied to a stream. This type can be used in conjunction with
1621/// `AudioStreamType` or `VideoStreamType` to represent a medium-specific compressed type.
1622#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1623pub struct Compression {
1624    /// The type of compression applied to the stream. This is generally one of the *_ENCODING_*
1625    /// values, though `AUDIO_ENCODING_LPCM` and `VIDEO_ENCODING_UNCOMPRESSED` must not be used,
1626    /// because those encodings are regarded as uncompressed.
1627    pub type_: String,
1628    /// Type-specific, opaque 'out-of-band' parameters describing the compression of the stream.
1629    pub parameters: Option<Vec<u8>>,
1630}
1631
1632impl fidl::Persistable for Compression {}
1633
1634/// EncryptionPattern
1635///
1636/// Pattern encryption utilizes a pattern of encrypted and clear 16 byte blocks
1637/// over the protected range of a subsample (the encrypted_bytes of a
1638/// `SubsampleEntry`). This structure specifies the number of encrypted data
1639/// blocks followed by the number of clear data blocks.
1640#[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/// Parameter
1657///
1658/// Generic parameter.
1659///
1660/// We want to minimize use of this generic "Parameter" structure by natively
1661/// defining as many stream-specific parameter semantics as we can.
1662#[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/// PcmFormat
1672///
1673/// PCM audio format details.
1674#[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/// Settings for an SBC Encoder.
1702///
1703/// SBC Encoders take signed little endian 16 bit linear PCM samples and
1704/// return encoded SBC frames. SBC encoder PCM data in batches of
1705/// `sub_bands * block_count` PCM frames. This encoder will accept PCM data on
1706/// arbitrary frame boundaries, but the output flushed when EOS is queued may be
1707/// zero-padded to make a full batch for encoding.
1708#[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    /// SBC bit pool value.
1715    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/// Describes a packet consumed by `StreamSink` or produced by `StreamSource`.
1729#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1730#[repr(C)]
1731pub struct StreamPacket {
1732    /// Time at which the packet is to be presented, according to the
1733    /// presentation clock.
1734    pub pts: i64,
1735    /// ID of the payload buffer used for this packet.
1736    ///
1737    /// When this struct is used with `StreamBufferSet`, this field is the ID of
1738    /// a payload buffer provided via `StreamBufferSet.AddPayloadBuffer`. In
1739    /// that case, this value must identify a payload buffer in the current set.
1740    /// Other interfaces may define different semantics for this field.
1741    pub payload_buffer_id: u32,
1742    /// Offset of the packet payload in the payload buffer.
1743    ///
1744    /// This value plus the `payload_size` value must be less than or equal to
1745    /// the size of the referenced payload buffer.
1746    pub payload_offset: u64,
1747    /// Size in bytes of the payload.
1748    ///
1749    /// This value plus the `payload_offest` value must be less than or equal to
1750    /// the size of the referenced payload buffer.
1751    pub payload_size: u64,
1752    /// An bitwise-or'ed set of flags (see constants below) describing
1753    /// properties of this packet.
1754    pub flags: u32,
1755    /// The buffer configuration associated with this packet. The semantics of
1756    /// this field depend on the interface with which this struct is used.
1757    /// In many contexts, this field is not used. This field is intended for
1758    /// situations in which buffer configurations (i.e. sets of payload buffers)
1759    /// are explicitly identified. In such cases, the `payload_buffer_id` refers
1760    /// to a payload buffer in the buffer configuration identified by this
1761    /// field.
1762    pub buffer_config: u64,
1763    /// The stream segment associated with this packet. The semantics of this
1764    /// field depend on the interface with which this struct is used. In many
1765    /// contexts, this field is not used. This field is intended to distinguish
1766    /// contiguous segments of the stream where stream properties (e.g.
1767    /// encoding) may differ from segment to segment.
1768    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/// Describes the type of an elementary stream.
1914#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1915pub struct StreamType {
1916    /// Medium-specific type information.
1917    pub medium_specific: MediumSpecificStreamType,
1918    /// Encoding (see constants below). This value is represented as a string
1919    /// so that new encodings can be introduced without modifying this file.
1920    pub encoding: String,
1921    /// Encoding-specific parameters, sometimes referred to as 'out-of-band
1922    /// data'. Typically, this data is associated with a compressed stream and
1923    /// provides parameters required to decompress the stream. This data is
1924    /// generally opaque to all parties except the producer and consumer of the
1925    /// stream.
1926    pub encoding_parameters: Option<Vec<u8>>,
1927}
1928
1929impl fidl::Persistable for StreamType {}
1930
1931/// Describes the type of a subpicture elementary stream.
1932#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1933pub struct SubpictureStreamType;
1934
1935impl fidl::Persistable for SubpictureStreamType {}
1936
1937/// SubsampleEntry
1938///
1939/// A subsample is a byte range within a sample consisting of a clear byte range
1940/// followed by an encrypted byte range. This structure specifies the size of
1941/// each range in the subsample.
1942#[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/// Describes the type of a text elementary stream.
1952#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1953pub struct TextStreamType;
1954
1955impl fidl::Persistable for TextStreamType {}
1956
1957/// A TimelineFunction represents a relationship between a subject timeline and a
1958/// reference timeline with a linear relation.
1959///
1960/// For example, consider a common use case in which reference time is the
1961/// monotonic clock of a system and subject time is intended presentation time
1962/// for some media such as a video.
1963///
1964/// `reference_time` is the value of the monotonic clock at the beginning of
1965/// playback. `subject_time` is 0 assuming playback starts at the beginning of
1966/// the media. We then choose a `reference_delta` and `subject_delta` so that
1967/// `subject_delta` / `reference_delta` represents the desired playback rate,
1968/// e.g. 0/1 for paused and 1/1 for normal playback.
1969///
1970/// ## Formulas
1971///
1972/// With a function we can determine the subject timeline value `s` in terms of
1973/// reference timeline value `r` with this formula (where `reference_delta` > 0):
1974///
1975///   s = (r - reference_time) * (subject_delta / reference_delta) + subject_time
1976///
1977/// And similarly we can find the reference timeline value `r` in terms of
1978/// subject timeline value `s` with this formula (where `subject_delta` > 0):
1979///
1980///   r = (s - subject_time) * (reference_delta / subject_delta) + referenc_time
1981///
1982/// ## Choosing time values
1983///
1984/// Time values can be arbitrary and our linear relation will of course be the
1985/// same, but we can use them to represent the bounds of pieces in a piecewise
1986/// linear relation.
1987///
1988/// For example, if a user performs skip-chapter, we might want to describe
1989/// this with a TimelineFunction whose `subject_time` is the time to skip to,
1990/// `reference_time` is now plus some epsilon, and delta ratio is 1/1 for normal
1991/// playback rate.
1992#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1993#[repr(C)]
1994pub struct TimelineFunction {
1995    /// A value from the subject timeline that correlates to reference_time.
1996    pub subject_time: i64,
1997    /// A value from the reference timeline that correlates to subject_time.
1998    pub reference_time: i64,
1999    /// The change in the subject timeline corresponding to reference_delta.
2000    pub subject_delta: u32,
2001    /// The change in the reference timeline corresponding to subject_delta.
2002    /// Cannot be zero.
2003    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/// Describes the type of a video elementary stream.
2033#[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    /// Dimensions of the video frames as displayed in pixels.
2038    pub width: u32,
2039    pub height: u32,
2040    /// Dimensions of the video frames as encoded in pixels. These values must
2041    /// be equal to or greater than the respective width/height values.
2042    pub coded_width: u32,
2043    pub coded_height: u32,
2044    /// The aspect ratio of a single pixel as frames are intended to be
2045    /// displayed.
2046    pub pixel_aspect_ratio_width: u32,
2047    pub pixel_aspect_ratio_height: u32,
2048    /// The number of bytes per 'coded' row in the primary video plane.
2049    pub stride: u32,
2050}
2051
2052impl fidl::Persistable for VideoStreamType {}
2053
2054/// VideoUncompressedFormat
2055///
2056/// Uncompressed video format details.
2057#[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/// AudioCompressedFormatCvsd contains no fields for now since we will be
2089/// using the parameter values recommended by Bluetooth Core Spec v5.3
2090/// section 9.2.
2091#[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/// AudioCompressedFormatLc3 contains no fields. The required parameters
2100/// for setting up the decoder would be embedded as Codec_Specific_Configuration
2101/// (Assigned Numbers section 6.12.5) in `FormatDetails.oob_bytes`.
2102#[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/// Represents the status of the consumer. In the initial status, `error` and
2111/// `presentation_timeline` are absent. The lead time fields are always present.
2112#[derive(Clone, Debug, Default, PartialEq)]
2113pub struct AudioConsumerStatus {
2114    /// If present, indicates an error condition currently in effect. Absent if no error.
2115    pub error: Option<AudioConsumerError>,
2116    /// If present, indicates the current relationship between the presentation timeline
2117    /// and local monotonic clock, both in nanosecond units. If not present,
2118    /// indicates there is no relationship. Absent initially.
2119    ///
2120    /// 'Presentation timeline' refers to the `pts` (presentation timestamp) values on the packets.
2121    /// This timeline function can be used to determine the local monotonic clock time that a
2122    /// packet will be presented based on that packet's `pts` value.
2123    pub presentation_timeline: Option<TimelineFunction>,
2124    /// Indicates the minimum lead time in nanoseconds supported by this
2125    /// `AudioConsumer`.  Or in other words, how small of a gap between the
2126    /// `media_time` provided to `AudioConsumer.Start` and the pts on the first
2127    /// packet can be. Values outside this range will be clipped.
2128    pub min_lead_time: Option<u64>,
2129    /// Indicates the maximum lead time in nanoseconds supported by this
2130    /// `AudioConsumer`.  Or in other words, how large of a gap between the
2131    /// `media_time` provided to `AudioConsumer.Start` and the pts on the first
2132    /// packet can be. Values outside this range will be clipped.
2133    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/// Settings for CVSD Encoders. It contains no fields for now since we will be
2141/// using the parameter values recommended by Bluetooth Core Spec v5.3
2142/// section 9.2.
2143#[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/// DecryptedFormat
2152///
2153/// This describes the format of the decrypted content. It is required to be
2154/// sent by the StreamProcessor server prior to the delivery of output packets.
2155/// Currently, there is no additional format details for decrypted output.
2156#[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/// EncryptedFormat
2166///
2167/// The stream format details payload of a decrypting stream processor. This is
2168/// a sparsely populated table to specify parameters necessary for decryption
2169/// other than the data stream. It is only necessary to update fields if they
2170/// changed, but not an error if the same value is repeated.
2171#[derive(Clone, Debug, Default, PartialEq)]
2172pub struct EncryptedFormat {
2173    /// `init_vector` is used in combination with a key and a block of content
2174    /// to create the first cipher block in a chain and derive subsequent cipher
2175    /// blocks in a cipher block chain.
2176    /// Usage:
2177    ///  - It is required to be set prior to the delivery of input packets to a
2178    ///    decryptor.
2179    ///  - This may be changed multiple times during a data stream.
2180    pub init_vector: Option<Vec<u8>>,
2181    /// `subsamples` is used to identify the clear and encrypted portions of a
2182    /// subsample.
2183    /// Usage:
2184    ///  - For whole sample encryption, this parameter should not be sent.
2185    ///  - This may be changed multiple times during a data stream.
2186    pub subsamples: Option<Vec<SubsampleEntry>>,
2187    /// `pattern` is used to identify the clear and encrypted blocks for pattern
2188    /// based encryption.
2189    /// Usage:
2190    /// - This is not allowed for CENC and CBC1 and required for CENS and CBCS.
2191    /// - If required, it must be set prior to the delivery of input packets to
2192    ///   a decryptor.
2193    /// - This may be changed multiple times during a data stream.
2194    pub pattern: Option<EncryptionPattern>,
2195    /// `scheme` specifies which encryption scheme to use, such as
2196    /// `fuchsia.media.ENCRYPTION_SCHEME_CENC`.
2197    /// Usage:
2198    ///  - It is required to be set prior to delivery of input packets.
2199    ///  - Changing the scheme mid-stream is only permitted in some scenarios.
2200    ///    Once an encrypted scheme is selected for a stream, the scheme may
2201    ///    only be set to `fuchsia.media.ENCRYPTION_SCHEME_UNENCRYPTED` or that
2202    ///    same initial encrypted scheme. The scheme may be set to
2203    ///    `fuchsia.media.ENCRYPTION_SCHEME_UNENCRYPTED` at any point.
2204    pub scheme: Option<String>,
2205    /// `key_id` identifies the key that should be used for decrypting
2206    /// subsequent data.
2207    /// Usage:
2208    ///  - It is required to be set prior to delivery of input packets to a
2209    ///    decryptor.
2210    ///  - This may be changed multiple times during a data stream.
2211    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/// FormatDetails
2219///
2220/// This describes/details the format on input or output of a StreamProcessor
2221/// (separate instances for input vs. output).
2222#[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    /// Instructs an encoder on how to encode raw data.
2230    ///
2231    /// Decoders may ignore this field but are entitled to rejected requests with
2232    /// this field set because it doesn't make sense.
2233    pub encoder_settings: Option<EncoderSettings>,
2234    /// The number of ticks of the timebase of input packet timestamp_ish values
2235    /// per second.
2236    ///
2237    /// The timebase is only used used for optional extrapolation of timestamp_ish
2238    /// values when an input timestamp which applies to byte 0 of the valid portion
2239    /// of the input packet does not correspond directly to byte 0 of the valid
2240    /// portion of any output packet.
2241    ///
2242    /// Leave unset if timestamp extrapolation is not needed, either due to lack of
2243    /// timestamps on input, or due to input being provided in increments of the
2244    /// encoder's input chunk size (based on the encoder settings and calculated
2245    /// independently by the client).  Set if timestamp extrapolation is known to be
2246    /// needed or known to be acceptable to the client.
2247    pub timebase: Option<u64>,
2248    /// The codec profile for the given encoder or decoder.
2249    ///
2250    /// For encoders: This value is completely optional. A client may want to specify the codec
2251    /// profile used for protocol compatibility reasons (i.e. WebRTC). However if the value is not
2252    /// set then the the encoder is free to choose any supported codec profile.
2253    ///
2254    /// For decoders: This value is optional but providing it is best practice (at least of
2255    /// unencrypted streams). Container formats include the encoded profile and this should be
2256    /// provided to the decoder. Certain formats like VP9 and AV1 include the encoded profile in
2257    /// their elementary bitstream so it is possible for those decoders to figure out the profile
2258    /// the stream is encoded in. Regardless, clients should provide the encoded profile if
2259    /// possible.
2260    pub profile: Option<CodecProfile>,
2261    #[doc(hidden)]
2262    pub __source_breaking: fidl::marker::SourceBreaking,
2263}
2264
2265impl fidl::Persistable for FormatDetails {}
2266
2267/// Settings for H264 Encoders.
2268#[derive(Clone, Debug, Default, PartialEq)]
2269pub struct H264EncoderSettings {
2270    /// Target bits per second for encoded stream.
2271    /// If omitted, interpreted as 200,000.
2272    pub bit_rate: Option<u32>,
2273    /// Target frames per second for encoded stream.
2274    /// If omitted, interpreted as 30.
2275    pub frame_rate: Option<u32>,
2276    /// Number of pictures per keyframe.  Setting to 0 will disable key frame
2277    /// encoding, except for if force_key_frame is set to true.
2278    /// If omitted, interpreted as 8.
2279    pub gop_size: Option<u32>,
2280    /// Whether to enable frame rate adjustments in order to meet target bitrate.
2281    /// If omitted, interpreted as false.
2282    pub variable_frame_rate: Option<bool>,
2283    /// Lowest frame rate allowed if `variable_frame_rate` is enabled. If
2284    /// omitted, interpreted as 10.
2285    pub min_frame_rate: Option<u32>,
2286    /// If true, next frame encoded will be a key frame. If omitted, interpreted
2287    /// as false.
2288    pub force_key_frame: Option<bool>,
2289    /// Allow customization of quantization parameters for encoding. Each frame
2290    /// submitted after setting this will use the new values. If omitted, no
2291    /// change from encoder defaults is made.
2292    pub quantization_params: Option<H264QuantizationParameters>,
2293    #[doc(hidden)]
2294    pub __source_breaking: fidl::marker::SourceBreaking,
2295}
2296
2297impl fidl::Persistable for H264EncoderSettings {}
2298
2299/// Customization of h264 encoder parameters for macroblock quantization. The values
2300/// can range from 0 to 51, with lower numbers indicating higher
2301/// quality/bitrate. While encoders should support these fields if feasible,
2302/// some encoders may ignore these fields. It's ok to not set this table, or
2303/// not set some of the fields in this table, as encoders can determine their
2304/// own defaults. If the targeted bitrate can't be achieved with the specified values,
2305/// then the user should expect the resulting encoded stream bitrate to differ from
2306/// the requested bitrate.
2307#[derive(Clone, Debug, Default, PartialEq)]
2308pub struct H264QuantizationParameters {
2309    /// Starting value for quantization of key frames.
2310    pub i_base: Option<u32>,
2311    /// Smallest allowed value for quantization of key frames.
2312    pub i_min: Option<u32>,
2313    /// Largest allowed value for quantization of key frames.
2314    pub i_max: Option<u32>,
2315    /// Starting value for quantization of predicted frames.
2316    pub p_base: Option<u32>,
2317    /// Smallest allowed value for quantization of predicted frames.
2318    pub p_min: Option<u32>,
2319    /// Largest allowed value for quantization of predicted frames.
2320    pub p_max: Option<u32>,
2321    #[doc(hidden)]
2322    pub __source_breaking: fidl::marker::SourceBreaking,
2323}
2324
2325impl fidl::Persistable for H264QuantizationParameters {}
2326
2327/// Settings for HEVC/H265 Encoders.
2328#[derive(Clone, Debug, Default, PartialEq)]
2329pub struct HevcEncoderSettings {
2330    /// Target bits per second for encoded stream. Defaults to 200,000 if
2331    /// omitted.
2332    pub bit_rate: Option<u32>,
2333    /// Target frames per second for encoded stream. Defaults to 30 if omitted.
2334    pub frame_rate: Option<u32>,
2335    /// Number of pictures per keyframe. Defaults to 8 if omitted.
2336    pub gop_size: Option<u32>,
2337    #[doc(hidden)]
2338    pub __source_breaking: fidl::marker::SourceBreaking,
2339}
2340
2341impl fidl::Persistable for HevcEncoderSettings {}
2342
2343/// Configuration for a capturer which will receive a stream from an
2344/// input device.
2345#[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/// Settings for LC3 Encoders. Contains parameters stated in LC3 Specification v1.0.
2356/// Contains fields that are not represented by PcmFormat.
2357#[derive(Clone, Debug, Default, PartialEq)]
2358pub struct Lc3EncoderSettings {
2359    /// External byte count values to be used for the frame encoding of audio.
2360    /// According to the LC3 Specification v1.0, each audio channel could have different
2361    /// output byte size value, but for Fuchsia use case, we use the same `nbytes` value
2362    /// for all channels.
2363    pub nbytes: Option<u16>,
2364    /// Frame duration is used together with sampling frequency to determine the
2365    /// frame size.
2366    pub frame_duration: Option<Lc3FrameDuration>,
2367    #[doc(hidden)]
2368    pub __source_breaking: fidl::marker::SourceBreaking,
2369}
2370
2371impl fidl::Persistable for Lc3EncoderSettings {}
2372
2373/// Configuration for a capturer which will receive a loopback stream
2374/// a system output.
2375#[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/// Settings for the mSBC encoder. There are no settings as the mSBC encoder uses the values
2384/// required by HFP Spec v1.8.
2385#[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/// A Packet represents a chunk of input or output data to or from a stream
2394/// processor.
2395///
2396/// stream processor output:
2397///
2398/// While the Packet is outstanding with the client via OnOutputPacket(), the
2399/// stream processor will avoid modifying the referenced output data.  After the
2400/// client calls RecycleOutputPacket(packet_index), the stream processor is
2401/// notified that the client is again ok with the referenced data changing.
2402///
2403/// stream processor input:
2404///
2405/// The client initially has all packet_index(es) available to fill, and later
2406/// gets packet_index(s) that are again ready to fill via OnFreeInputPacket().
2407/// The client must not modify the referenced data in between QueueInputPacket()
2408/// and OnFreeInputPacket().
2409#[derive(Clone, Debug, Default, PartialEq)]
2410pub struct Packet {
2411    pub header: Option<PacketHeader>,
2412    /// Which buffer this packet refers to.  For single-buffer mode this will
2413    /// always be 0, but for multi-buffer mode, a given in-flight interval of a
2414    /// packet can refer to any buffer.  The packet has an associated buffer only
2415    /// while the packet is in-flight, not while the packet is free.
2416    ///
2417    /// The default value makes accidental inappropriate use of index 0 less
2418    /// likely (will tend to complain in an obvious way if not filled out
2419    /// instead of a non-obvious data corruption when decoding buffer 0
2420    /// repeatedly instead of the correct buffers).
2421    ///
2422    /// TODO(dustingreen): Try to make FIDL table defaults have meaning, and not
2423    /// complain about !has when accessing the field.  For now the default
2424    /// specified here does nothing.
2425    pub buffer_index: Option<u32>,
2426    /// The value 1 is the lowest permitted value after stream processor
2427    /// creation.  Values sent by the client must be odd.  Values must only
2428    /// increase.
2429    ///
2430    /// A stream_lifetime_ordinal represents the lifetime of a stream.  All
2431    /// messages that are specific to a stream have the stream_lifetime_ordinal
2432    /// value and the value is the same for all messages relating to a given
2433    /// stream.
2434    pub stream_lifetime_ordinal: Option<u64>,
2435    /// Which part of the relevant buffer is this packet using.  These are valid
2436    /// for input data that's in-flight to the stream processor, and are valid
2437    /// for output data from the stream processor.
2438    ///
2439    /// For compressed formats and uncompressed audio, the data in
2440    /// [start_offset, start_offset + valid_length_bytes) is the contiguously
2441    /// valid data referred to by this packet.
2442    ///
2443    /// For uncompressed video frames, FormatDetails is the primary means of
2444    /// determining which bytes are relevant.  The offsets in FormatDetails
2445    /// are relative to the start_offset here.  The valid_length_bytes must be
2446    /// large enough to include the full last line of pixel data, including the
2447    /// full line stride of the last line (not just the width in pixels of the
2448    /// last line).
2449    ///
2450    /// Despite these being filled out, some uncompressed video buffers are of
2451    /// types that are not readable by the CPU.  These fields being here don't
2452    /// imply there's any way for the CPU to read an uncompressed frame.
2453    pub start_offset: Option<u32>,
2454    /// This must be > 0.
2455    ///
2456    /// The semantics for valid data per packet vary depending on data type as
2457    /// follows.
2458    ///
2459    /// uncompressed video - A video frame can't be split across packets.  Each
2460    /// packet is one video frame.
2461    ///
2462    /// uncompressed audio - Regardless of float or int, linear or uLaw, or
2463    /// number of channels, a packet must contain an non-negative number of
2464    /// complete audio frames, where a single audio frame consists of data for
2465    /// all the channels for the same single point in time.  Any
2466    /// stream-processor-specific internal details re. lower rate sampling for
2467    /// LFE channel or the like should be hidden by the StreamProcessor server
2468    /// implementation.
2469    ///
2470    /// compressed data input - A packet must contain at least one byte of data.
2471    /// See also stream_input_bytes_min.  Splitting AUs at arbitrary byte
2472    /// boundaries is permitted, including at boundaries that are in AU headers.
2473    ///
2474    /// compressed data output - The stream processor is not required to fully
2475    /// fill each output packet's buffer.
2476    pub valid_length_bytes: Option<u32>,
2477    /// This value is not strictly speaking a timestamp.  It is an arbitrary
2478    /// unsigned 64-bit number that, under some circumstances, will be passed by
2479    /// a stream processor unmodified from an input packet to the
2480    /// exactly-corresponding output packet.
2481    ///
2482    /// For timestamp_ish values to be propagated from input to output the
2483    /// following conditions must be true:
2484    ///  * promise_separate_access_units_on_input must be true
2485    ///  * has_timestamp_ish must be true for a given input packet, to have that
2486    ///    timestamp_ish value (potentially) propagate through to an output
2487    ///  * the StreamProcessor instance itself decides (async) that the input
2488    ///    packet generates an output packet - if a given input never generates
2489    ///    an output packet then the timestamp_ish value on the input will never
2490    ///    show up on any output packet - depending on the characteristics of the
2491    ///    input and output formats, and whether a decoder is willing to join
2492    ///    mid-stream, etc this can be more or less likely to occur, but clients
2493    ///    should be written to accommodate timestamp_ish values that are fed on
2494    ///    input but never show up on output, at least to a reasonable degree
2495    ///    (not crashing, not treating as an error).
2496    pub timestamp_ish: Option<u64>,
2497    /// If promise_separate_access_units_on_input (TODO(dustingreen): or any
2498    /// similar mode for output) is true, this bool must be set appropriately
2499    /// depending on whether byte 0 _is_ or _is not_ the start of an access
2500    /// unit. The client is required to know, and required to set this boolean
2501    /// properly. The server is allowed to infer that when this boolean is
2502    /// false, byte 0 is the first byte of a continuation of a
2503    /// previously-started AU.  (The byte at start_offset is "byte 0".)
2504    ///
2505    /// If promise_separate_access_units_on_input is false, this boolean is
2506    /// ignored.
2507    pub start_access_unit: Option<bool>,
2508    /// A client is never required to set this boolean to true.
2509    ///
2510    /// If promise_separate_access_units_on_input is true, for input data, this
2511    /// boolean must be false if the last byte of this packet is not the last
2512    /// byte of an AU, and this boolean _may_ be true if the last byte of this
2513    /// packet is the last byte of an AU.  A client delivering one AU at a time
2514    /// that's interested in the lowest possible latency via the decoder should
2515    /// set this boolean to true when it can be set to true.
2516    ///
2517    /// If promise_separate_access_units_on_input is false, this boolean is
2518    /// ignored.
2519    pub known_end_access_unit: Option<bool>,
2520    /// Used for compressed video packets. If not present should be assumed to
2521    /// be unknown. If false, indicates the packet is not part of a key frame. If
2522    /// true, indicates the packet is part of a key frame.
2523    pub key_frame: Option<bool>,
2524    #[doc(hidden)]
2525    pub __source_breaking: fidl::marker::SourceBreaking,
2526}
2527
2528impl fidl::Persistable for Packet {}
2529
2530/// PacketHeader
2531///
2532/// When referring to a free packet, we use PacketHeader alone instead of
2533/// Packet, since while a packet is free it doesn't really have meaningful
2534/// offset or length etc.
2535///
2536/// A populated Packet also has a PacketHeader.
2537#[derive(Clone, Debug, Default, PartialEq)]
2538pub struct PacketHeader {
2539    /// This is which buffer configuration lifetime this header is referring to.
2540    ///
2541    /// A packet_index is only really meaningful with respect to a particular
2542    /// buffer_lifetime_ordinal.
2543    ///
2544    /// See StreamBufferPartialSettings.buffer_lifetime_ordinal.
2545    ///
2546    /// For QueueInputPacket(), a server receiving a buffer_lifetime_ordinal that
2547    /// isn't the current input buffer_lifetime_ordinal will close the channel.
2548    ///
2549    /// For OnFreeInputPacket() and RecycleOutputPacket(), the receiver (client
2550    /// or server) must ignore a message with stale buffer_lifetime_ordinal.
2551    pub buffer_lifetime_ordinal: Option<u64>,
2552    /// The overall set of packet_index values is densely packed from 0..count-1
2553    /// for input and output separately.  They can be queued in any order.
2554    ///
2555    /// Both the client and server should validate the packet_index against the
2556    /// known bound and disconnect if it's out of bounds.
2557    ///
2558    /// When running in single-buffer mode, the buffer index is always 0.
2559    ///
2560    /// The packet_index values don't imply anything about order of use of
2561    /// packets. The client should not expect the ordering to remain the same
2562    /// over time - the stream processor is free to hold on to an input or
2563    /// output packet for a while during which other packet_index values may be
2564    /// used multiple times.
2565    ///
2566    /// For a given properly-functioning StreamProcessor instance, packet_index
2567    /// values will be unique among concurrently-outstanding packets.  Servers
2568    /// should validate that a client isn't double-using a packet and clients
2569    /// should validate as necessary to avoid undefined or unexpected client
2570    /// behavior.
2571    pub packet_index: Option<u32>,
2572    #[doc(hidden)]
2573    pub __source_breaking: fidl::marker::SourceBreaking,
2574}
2575
2576impl fidl::Persistable for PacketHeader {}
2577
2578/// This struct conveys the buffer_constraints_version_ordinal.
2579///
2580/// Historically this table conveyed more fields than it currently does, but
2581/// those fields are all deprecated in favor of using sysmem instead.
2582///
2583/// There are separate instances of this struct for stream input and stream
2584/// output.
2585///
2586/// Notes about fields:
2587///
2588/// For uncompressed video, separate and complete frames in their
2589/// separate buffers (buffer-per-packet mode) are always a requirement.
2590#[derive(Clone, Debug, Default, PartialEq)]
2591pub struct StreamBufferConstraints {
2592    /// This is a version number the server sets on the constraints to allow the
2593    /// server to determine when the client has caught up with the latest
2594    /// constraints sent by the server.  The server won't emit output data until
2595    /// the client has configured output settings and buffers with a
2596    /// buffer_constraints_version_ordinal >= the latest
2597    /// buffer_constraints_version_ordinal that had
2598    /// buffer_constraints_action_required true.  See
2599    /// buffer_constraints_action_required comments for more.
2600    ///
2601    /// A buffer_constraints_version_ordinal of 0 is not permitted, to simplify
2602    /// initial state handling.  Other than 0, both odd and even version ordinals
2603    /// are allowed (in contrast to the stream_lifetime_ordinal, neither the
2604    /// client nor server ever has a reason to consider the latest version to be
2605    /// stale, so there would be no benefit to disallowing even values).
2606    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/// Deprecated.  Use SetStreamBufferPartialSettings() and
2626/// StreamBufferPartialSettings instead.
2627#[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/// The stream-processor-controlled output configuration, including both
2642/// StreamBufferConstraints for the output and FormatDetails for the output.
2643#[derive(Clone, Debug, Default, PartialEq)]
2644pub struct StreamOutputConstraints {
2645    /// A client which always immediately re-configures output buffers on
2646    /// receipt of OnOutputConstraints() with buffer_constraints_action_required
2647    /// true can safely ignore this field.
2648    ///
2649    /// A client is permitted to ignore an OnOutputConstraints() message even with
2650    /// buffer_constraints_action_required true if the client knows the server
2651    /// has already been told to discard the remainder of the stream with the
2652    /// same stream_lifetime_ordinal or if this stream_lifetime_ordinal field is
2653    /// set to 0.  The server is required to re-send needed output config via
2654    /// OnOutputConstraints() with new stream_lifetime_ordinal and
2655    /// buffer_constraints_action_required true, if the most recent completed
2656    /// server-side output config isn't what the server wants/needs yet for the
2657    /// new stream.
2658    pub stream_lifetime_ordinal: Option<u64>,
2659    /// When the buffer constraints are delivered, they indicate whether action
2660    /// is required.  A false value here permits delivery of constraints which
2661    /// are fresher without forcing a buffer reconfiguration.  If this is false,
2662    /// a client cannot assume that it's safe to immediately re-configure output
2663    /// buffers.  If this is true, the client can assume it's safe to
2664    /// immediately configure output buffers once.
2665    ///
2666    /// A client is permitted to ignore buffer constraint versions which have
2667    /// buffer_constraints_action_required false.  The server is not permitted
2668    /// to change buffer_constraints_action_required from false to true for the
2669    /// same buffer_constraints_version_ordinal.
2670    ///
2671    /// For each configuration, a client must use new buffers, never buffers
2672    /// that were previously used for anything else, and never buffers
2673    /// previously used for any other StreamProcessor purposes.  This rule
2674    /// exists for multiple good reasons, relevant to both mid-stream changes,
2675    /// and changes on stream boundaries. A client should just use new buffers
2676    /// each time.
2677    ///
2678    /// When this is true, the server has already de-refed as many low-level
2679    /// output buffers as the server can while still performing efficient
2680    /// transition to the new buffers and will de-ref the rest asap.  A Sync()
2681    /// is not necessary to achieve non-overlap of resource usage to the extent
2682    /// efficiently permitted by the formats involved.
2683    ///
2684    /// If buffer_constraints_action_required is true, the server _must_ not
2685    /// deliver more output data until after output buffers have been configured
2686    /// (or re-configured) by the client.
2687    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    /// A client is permitted to ignore an OnOutputFormat() message even with
2698    /// buffer_constraints_action_required true if the client knows the server
2699    /// has already been told to discard the remainder of the stream with the
2700    /// same stream_lifetime_ordinal or if this stream_lifetime_ordinal field is
2701    /// set to 0.  The server is required to re-send needed output config via
2702    /// OnOutputConstraints() with new stream_lifetime_ordinal and
2703    /// buffer_constraints_action_required true, if the most recent completed
2704    /// server-side output config isn't what the server wants/needs yet for the
2705    /// new stream.
2706    ///
2707    /// The server is required to send an OnOutputFormat() before the first
2708    /// output packet of a stream.
2709    pub stream_lifetime_ordinal: Option<u64>,
2710    /// If format_details.format_details_version_ordinal changes, the client
2711    /// should inspect the new format details and determine if it must adjust to
2712    /// the new format. The server guarantees that if the format has changed, then
2713    /// format_details.format_details_version_ordinal will change, but a change
2714    /// to format_details.format_details_version_ordinal does not guarantee that
2715    /// the format details actually changed.  Servers are strongly encouraged to
2716    /// not change format_details.format_details_version_ordinal other than
2717    /// before the first output data of a stream unless there is a real
2718    /// mid-stream format change in the stream.  Unnecessary mid-stream format
2719    /// changes can cause simpler clients that have no need to handle mid-stream
2720    /// format changes to just close the channel.  Format changes before the
2721    /// first output data of a stream are not "mid-stream" in this context -
2722    /// those can be useful for stream format detection / setup reasons.
2723    ///
2724    /// Note that in case output buffers don't really need to be re-configured
2725    /// despite a format change, a server is encouraged, but not required, to
2726    /// set buffer_constraints_action_required false on the message that conveys
2727    /// the new format details.  Simpler servers may just treat the whole output
2728    /// situation as one big thing and demand output buffer reconfiguration on
2729    /// any change in the output situation.
2730    ///
2731    /// A client may or may not actually handle a new buffer_constraints with
2732    /// buffer_constraints_action_required false, but the client should always
2733    /// track the latest format_details.
2734    ///
2735    /// An updated format_details is ordered with respect to emitted output
2736    /// packets, and applies to all subsequent packets until the next
2737    /// format_details with larger version_ordinal.  A simple client that does
2738    /// not intend to handle mid-stream format changes should still keep track
2739    /// of the most recently received format_details until the first output
2740    /// packet arrives, then lock down the format details, handle those format
2741    /// details, and verify that any
2742    /// format_details.format_details_version_ordinal received from the server
2743    /// is the same as the locked-down format_details, until the client is done
2744    /// with the stream.  Even such a simple client must tolerate
2745    /// format_details.format_details_version_ordinal changing multiple times
2746    /// before the start of data output from a stream (any stream - the first
2747    /// stream or a subsequent stream).  This allows a stream processor to
2748    /// request that output buffers and output format be configured
2749    /// speculatively, and for the output config to be optionally adjusted by
2750    /// the server before the first data output from a stream after the server
2751    /// knows everything it needs to know to fully establish the initial output
2752    /// format details.  This simplifies stream processor server implementation,
2753    /// and allows a clever stream processor server to guess it's output config
2754    /// for lower latency before any input data, while still being able to fix
2755    /// the output config (including format details) if the guess turns out to
2756    /// be wrong.
2757    ///
2758    /// Whether the format_details.format_details_version_ordinal will actually
2759    /// change mid-stream is a per-stream-processor and per-stream detail that
2760    /// is not specified in comments here, and in most cases also depends on
2761    /// whether the format changes on the input to the stream processor.
2762    /// Probably it'll be fairly common for a client to use a format which
2763    /// technically supports mid-stream format change, but the client happens to
2764    /// know that none of the streams the client intends to process will ever
2765    /// have a mid-stream format change.
2766    pub format_details: Option<FormatDetails>,
2767    #[doc(hidden)]
2768    pub __source_breaking: fidl::marker::SourceBreaking,
2769}
2770
2771impl fidl::Persistable for StreamOutputFormat {}
2772
2773/// A state of audio usages in which a policy decision has been made to temporarily
2774/// lower the volume of all streams with this usage.
2775#[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/// A state of audio usages in which a policy decision has been made to temporarily
2784/// mute the volume of all streams with this usage.
2785#[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/// A state of audio usages in which no policy actions are taken on any streams with the usage.
2794#[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/// Pattern that matches an unknown `AacTransport` member.
2832#[macro_export]
2833macro_rules! AacTransportUnknown {
2834    () => {
2835        _
2836    };
2837}
2838
2839// Custom PartialEq so that unknown variants are not equal to themselves.
2840impl 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/// Configuration for an audio Capturer.
2879#[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/// Pattern that matches an unknown `AudioCompressedFormat` member.
2910#[macro_export]
2911macro_rules! AudioCompressedFormatUnknown {
2912    () => {
2913        _
2914    };
2915}
2916
2917// Custom PartialEq so that unknown variants are not equal to themselves.
2918impl 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/// Represents a `AudioConsumer` error condition.
2959#[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/// AudioFormat
2976#[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/// AudioUncompressedFormat
2995#[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/// CryptoFormat
3012///
3013/// Crypto (encrypted or decrypted) format details.
3014#[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/// Pattern that matches an unknown `CryptoFormat` member.
3025#[macro_export]
3026macro_rules! CryptoFormatUnknown {
3027    () => {
3028        _
3029    };
3030}
3031
3032// Custom PartialEq so that unknown variants are not equal to themselves.
3033impl 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/// DomainFormat
3070#[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/// Settings for encoders that tell them how to encode raw
3091/// formats.
3092#[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/// Pattern that matches an unknown `EncoderSettings` member.
3108#[macro_export]
3109macro_rules! EncoderSettingsUnknown {
3110    () => {
3111        _
3112    };
3113}
3114
3115// Custom PartialEq so that unknown variants are not equal to themselves.
3116impl 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/// A union of all medium-specific stream type structs.
3163#[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/// Pattern that matches an unknown `Usage2` member.
3214#[macro_export]
3215macro_rules! Usage2Unknown {
3216    () => {
3217        _
3218    };
3219}
3220
3221// Custom PartialEq so that unknown variants are not equal to themselves.
3222impl 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/// The state of audio policy enforcement on a stream or set of streams.
3259#[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/// Pattern that matches an unknown `UsageState` member.
3271#[macro_export]
3272macro_rules! UsageStateUnknown {
3273    () => {
3274        _
3275    };
3276}
3277
3278// Custom PartialEq so that unknown variants are not equal to themselves.
3279impl 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/// Value
3318///
3319/// Generic "value" for use within generic "Parameter" struct.
3320#[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/// VideoCompressedFormat
3345///
3346/// Compressed video format details.
3347#[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/// VideoFormat
3364///
3365/// Video (compress or uncompressed) format details.  In this context,
3366/// "uncompressed" can include block-based image compression formats that still
3367/// permit fairly fast random access to image data.
3368#[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                // Copy the object into the buffer.
5090                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5094                // done second because the memcpy will write garbage to these bytes.
5095            }
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            // Zero out padding regions. There's no need to apply masks
5111            // because the unmasked parts will be overwritten by fields.
5112            // Write the fields.
5113            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            // Verify that padding bytes are zero.
5134            // Copy from the buffer into the object.
5135            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            // Delegate to tuple encoding.
5175            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            // Zero out padding regions. There's no need to apply masks
5205            // because the unmasked parts will be overwritten by fields.
5206            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            // Write the fields.
5215            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            // Verify that padding bytes are zero.
5243            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            // Delegate to tuple encoding.
5360            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            // Zero out padding regions. There's no need to apply masks
5380            // because the unmasked parts will be overwritten by fields.
5381            // Write the fields.
5382            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            // Verify that padding bytes are zero.
5402            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            // Delegate to tuple encoding.
5499            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            // Zero out padding regions. There's no need to apply masks
5521            // because the unmasked parts will be overwritten by fields.
5522            // Write the fields.
5523            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            // Verify that padding bytes are zero.
5547            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            // Delegate to tuple encoding.
5586            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            // Zero out padding regions. There's no need to apply masks
5608            // because the unmasked parts will be overwritten by fields.
5609            // Write the fields.
5610            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            // Verify that padding bytes are zero.
5632            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            // Delegate to tuple encoding.
5671            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            // Zero out padding regions. There's no need to apply masks
5693            // because the unmasked parts will be overwritten by fields.
5694            // Write the fields.
5695            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            // Verify that padding bytes are zero.
5719            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            // Delegate to tuple encoding.
5758            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            // Zero out padding regions. There's no need to apply masks
5780            // because the unmasked parts will be overwritten by fields.
5781            // Write the fields.
5782            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            // Verify that padding bytes are zero.
5806            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                // Copy the object into the buffer.
5855                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5859                // done second because the memcpy will write garbage to these bytes.
5860            }
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            // Zero out padding regions. There's no need to apply masks
5880            // because the unmasked parts will be overwritten by fields.
5881            // Write the fields.
5882            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            // Verify that padding bytes are zero.
5911            // Copy from the buffer into the object.
5912            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                // Copy the object into the buffer.
5954                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5958                // done second because the memcpy will write garbage to these bytes.
5959                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            // Zero out padding regions. There's no need to apply masks
5981            // because the unmasked parts will be overwritten by fields.
5982            // Write the fields.
5983            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            // Verify that padding bytes are zero.
6006            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            // Copy from the buffer into the object.
6025            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            // Delegate to tuple encoding.
6066            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            // Zero out padding regions. There's no need to apply masks
6086            // because the unmasked parts will be overwritten by fields.
6087            // Write the fields.
6088            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            // Verify that padding bytes are zero.
6110            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            // Delegate to tuple encoding.
6149            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            // Zero out padding regions. There's no need to apply masks
6169            // because the unmasked parts will be overwritten by fields.
6170            // Write the fields.
6171            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            // Verify that padding bytes are zero.
6193            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            // Delegate to tuple encoding.
6232            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            // Zero out padding regions. There's no need to apply masks
6252            // because the unmasked parts will be overwritten by fields.
6253            // Write the fields.
6254            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            // Verify that padding bytes are zero.
6276            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            // Delegate to tuple encoding.
6314            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            // Zero out padding regions. There's no need to apply masks
6334            // because the unmasked parts will be overwritten by fields.
6335            // Write the fields.
6336            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            // Verify that padding bytes are zero.
6358            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                // Copy the object into the buffer.
6407                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6411                // done second because the memcpy will write garbage to these bytes.
6412            }
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            // Zero out padding regions. There's no need to apply masks
6428            // because the unmasked parts will be overwritten by fields.
6429            // Write the fields.
6430            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            // Verify that padding bytes are zero.
6453            // Copy from the buffer into the object.
6454            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            // Delegate to tuple encoding.
6614            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            // Zero out padding regions. There's no need to apply masks
6634            // because the unmasked parts will be overwritten by fields.
6635            // Write the fields.
6636            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            // Verify that padding bytes are zero.
6658            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            // Delegate to tuple encoding.
6696            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            // Zero out padding regions. There's no need to apply masks
6726            // because the unmasked parts will be overwritten by fields.
6727            unsafe {
6728                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6729                (ptr as *mut u64).write_unaligned(0);
6730            }
6731            // Write the fields.
6732            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            // Verify that padding bytes are zero.
6760            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            // Delegate to tuple encoding.
6817            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            // Zero out padding regions. There's no need to apply masks
6839            // because the unmasked parts will be overwritten by fields.
6840            // Write the fields.
6841            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            // Verify that padding bytes are zero.
6863            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            // Delegate to tuple encoding.
6902            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            // Zero out padding regions. There's no need to apply masks
6922            // because the unmasked parts will be overwritten by fields.
6923            // Write the fields.
6924            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            // Verify that padding bytes are zero.
6946            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            // Delegate to tuple encoding.
6985            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            // Zero out padding regions. There's no need to apply masks
7011            // because the unmasked parts will be overwritten by fields.
7012            unsafe {
7013                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7014                (ptr as *mut u64).write_unaligned(0);
7015            }
7016            // Write the fields.
7017            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            // Verify that padding bytes are zero.
7040            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            // Delegate to tuple encoding.
7089            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            // Zero out padding regions. There's no need to apply masks
7115            // because the unmasked parts will be overwritten by fields.
7116            unsafe {
7117                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7118                (ptr as *mut u64).write_unaligned(0);
7119            }
7120            // Write the fields.
7121            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            // Verify that padding bytes are zero.
7144            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            // Delegate to tuple encoding.
7193            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            // Zero out padding regions. There's no need to apply masks
7213            // because the unmasked parts will be overwritten by fields.
7214            // Write the fields.
7215            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            // Verify that padding bytes are zero.
7237            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            // Delegate to tuple encoding.
7276            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            // Zero out padding regions. There's no need to apply masks
7302            // because the unmasked parts will be overwritten by fields.
7303            unsafe {
7304                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7305                (ptr as *mut u64).write_unaligned(0);
7306            }
7307            // Write the fields.
7308            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            // Verify that padding bytes are zero.
7331            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            // Delegate to tuple encoding.
7380            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            // Zero out padding regions. There's no need to apply masks
7406            // because the unmasked parts will be overwritten by fields.
7407            unsafe {
7408                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7409                (ptr as *mut u64).write_unaligned(0);
7410            }
7411            // Write the fields.
7412            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            // Verify that padding bytes are zero.
7435            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            // Delegate to tuple encoding.
7484            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            // Zero out padding regions. There's no need to apply masks
7504            // because the unmasked parts will be overwritten by fields.
7505            // Write the fields.
7506            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            // Verify that padding bytes are zero.
7528            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            // Delegate to tuple encoding.
7567            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            // Zero out padding regions. There's no need to apply masks
7593            // because the unmasked parts will be overwritten by fields.
7594            // Write the fields.
7595            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            // Verify that padding bytes are zero.
7621            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            // Delegate to tuple encoding.
7661            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            // Zero out padding regions. There's no need to apply masks
7687            // because the unmasked parts will be overwritten by fields.
7688            // Write the fields.
7689            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            // Verify that padding bytes are zero.
7715            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            // Delegate to tuple encoding.
7755            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            // Zero out padding regions. There's no need to apply masks
7783            // because the unmasked parts will be overwritten by fields.
7784            unsafe {
7785                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7786                (ptr as *mut u64).write_unaligned(0);
7787            }
7788            // Write the fields.
7789            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            // Verify that padding bytes are zero.
7817            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            // Delegate to tuple encoding.
7867            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            // Zero out padding regions. There's no need to apply masks
7895            // because the unmasked parts will be overwritten by fields.
7896            unsafe {
7897                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7898                (ptr as *mut u64).write_unaligned(0);
7899            }
7900            // Write the fields.
7901            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            // Verify that padding bytes are zero.
7929            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            // Delegate to tuple encoding.
7979            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            // Zero out padding regions. There's no need to apply masks
8005            // because the unmasked parts will be overwritten by fields.
8006            // Write the fields.
8007            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            // Verify that padding bytes are zero.
8033            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            // Delegate to tuple encoding.
8073            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            // Zero out padding regions. There's no need to apply masks
8099            // because the unmasked parts will be overwritten by fields.
8100            // Write the fields.
8101            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            // Verify that padding bytes are zero.
8124            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            // Delegate to tuple encoding.
8164            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            // Zero out padding regions. There's no need to apply masks
8184            // because the unmasked parts will be overwritten by fields.
8185            // Write the fields.
8186            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            // Verify that padding bytes are zero.
8208            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            // Delegate to tuple encoding.
8247            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            // Zero out padding regions. There's no need to apply masks
8267            // because the unmasked parts will be overwritten by fields.
8268            // Write the fields.
8269            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            // Verify that padding bytes are zero.
8291            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                // Copy the object into the buffer.
8340                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8345                // done second because the memcpy will write garbage to these bytes.
8346            }
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            // Zero out padding regions. There's no need to apply masks
8362            // because the unmasked parts will be overwritten by fields.
8363            // Write the fields.
8364            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            // Verify that padding bytes are zero.
8387            // Copy from the buffer into the object.
8388            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            // Delegate to tuple encoding.
8429            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            // Zero out padding regions. There's no need to apply masks
8455            // because the unmasked parts will be overwritten by fields.
8456            // Write the fields.
8457            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            // Verify that padding bytes are zero.
8483            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            // Delegate to tuple encoding.
8523            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            // Zero out padding regions. There's no need to apply masks
8545            // because the unmasked parts will be overwritten by fields.
8546            // Write the fields.
8547            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            // Verify that padding bytes are zero.
8569            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                // Copy the object into the buffer.
8626                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8632                // done second because the memcpy will write garbage to these bytes.
8633            }
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            // Zero out padding regions. There's no need to apply masks
8654            // because the unmasked parts will be overwritten by fields.
8655            // Write the fields.
8656            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            // Verify that padding bytes are zero.
8683            // Copy from the buffer into the object.
8684            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            // Delegate to tuple encoding.
8725            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            // Zero out padding regions. There's no need to apply masks
8745            // because the unmasked parts will be overwritten by fields.
8746            // Write the fields.
8747            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            // Verify that padding bytes are zero.
8769            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            // Delegate to tuple encoding.
8808            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            // Zero out padding regions. There's no need to apply masks
8834            // because the unmasked parts will be overwritten by fields.
8835            // Write the fields.
8836            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            // Verify that padding bytes are zero.
8862            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                // Copy the object into the buffer.
8912                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8917                // done second because the memcpy will write garbage to these bytes.
8918            }
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            // Zero out padding regions. There's no need to apply masks
8934            // because the unmasked parts will be overwritten by fields.
8935            // Write the fields.
8936            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            // Verify that padding bytes are zero.
8959            // Copy from the buffer into the object.
8960            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            // Delegate to tuple encoding.
9001            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            // Zero out padding regions. There's no need to apply masks
9031            // because the unmasked parts will be overwritten by fields.
9032            unsafe {
9033                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
9034                (ptr as *mut u64).write_unaligned(0);
9035            }
9036            // Write the fields.
9037            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            // Verify that padding bytes are zero.
9065            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            // Delegate to tuple encoding.
9121            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            // Zero out padding regions. There's no need to apply masks
9159            // because the unmasked parts will be overwritten by fields.
9160            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            // Write the fields.
9169            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            // Verify that padding bytes are zero.
9201            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            // Delegate to tuple encoding.
9276            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            // Zero out padding regions. There's no need to apply masks
9302            // because the unmasked parts will be overwritten by fields.
9303            // Write the fields.
9304            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            // Verify that padding bytes are zero.
9328            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            // Delegate to tuple encoding.
9368            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            // Zero out padding regions. There's no need to apply masks
9388            // because the unmasked parts will be overwritten by fields.
9389            // Write the fields.
9390            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            // Verify that padding bytes are zero.
9412            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                // Copy the object into the buffer.
9461                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9465                // done second because the memcpy will write garbage to these bytes.
9466            }
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            // Zero out padding regions. There's no need to apply masks
9482            // because the unmasked parts will be overwritten by fields.
9483            // Write the fields.
9484            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            // Verify that padding bytes are zero.
9507            // Copy from the buffer into the object.
9508            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                // Copy the object into the buffer.
9559                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9564                // done second because the memcpy will write garbage to these bytes.
9565            }
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            // Zero out padding regions. There's no need to apply masks
9581            // because the unmasked parts will be overwritten by fields.
9582            // Write the fields.
9583            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            // Verify that padding bytes are zero.
9606            // Copy from the buffer into the object.
9607            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                // Copy the object into the buffer.
9657                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9661                // done second because the memcpy will write garbage to these bytes.
9662            }
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            // Zero out padding regions. There's no need to apply masks
9681            // because the unmasked parts will be overwritten by fields.
9682            // Write the fields.
9683            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            // Verify that padding bytes are zero.
9707            // Copy from the buffer into the object.
9708            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                // Copy the object into the buffer.
9759                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9763                // done second because the memcpy will write garbage to these bytes.
9764            }
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            // Zero out padding regions. There's no need to apply masks
9783            // because the unmasked parts will be overwritten by fields.
9784            // Write the fields.
9785            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            // Verify that padding bytes are zero.
9809            // Copy from the buffer into the object.
9810            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                // Copy the object into the buffer.
9860                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9864                // done second because the memcpy will write garbage to these bytes.
9865            }
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            // Zero out padding regions. There's no need to apply masks
9884            // because the unmasked parts will be overwritten by fields.
9885            // Write the fields.
9886            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            // Verify that padding bytes are zero.
9910            // Copy from the buffer into the object.
9911            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                // Copy the object into the buffer.
9961                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9965                // done second because the memcpy will write garbage to these bytes.
9966            }
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            // Zero out padding regions. There's no need to apply masks
9985            // because the unmasked parts will be overwritten by fields.
9986            // Write the fields.
9987            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            // Verify that padding bytes are zero.
10011            // Copy from the buffer into the object.
10012            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            // Delegate to tuple encoding.
10053            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            // Zero out padding regions. There's no need to apply masks
10073            // because the unmasked parts will be overwritten by fields.
10074            // Write the fields.
10075            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            // Verify that padding bytes are zero.
10097            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            // Delegate to tuple encoding.
10136            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            // Zero out padding regions. There's no need to apply masks
10156            // because the unmasked parts will be overwritten by fields.
10157            // Write the fields.
10158            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            // Verify that padding bytes are zero.
10180            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                // Copy the object into the buffer.
10229                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10233                // done second because the memcpy will write garbage to these bytes.
10234            }
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            // Zero out padding regions. There's no need to apply masks
10253            // because the unmasked parts will be overwritten by fields.
10254            // Write the fields.
10255            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            // Verify that padding bytes are zero.
10282            // Copy from the buffer into the object.
10283            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            // Delegate to tuple encoding.
10324            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            // Zero out padding regions. There's no need to apply masks
10344            // because the unmasked parts will be overwritten by fields.
10345            // Write the fields.
10346            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            // Verify that padding bytes are zero.
10368            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            // Delegate to tuple encoding.
10406            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            // Zero out padding regions. There's no need to apply masks
10426            // because the unmasked parts will be overwritten by fields.
10427            // Write the fields.
10428            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            // Verify that padding bytes are zero.
10450            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            // Delegate to tuple encoding.
10488            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            // Zero out padding regions. There's no need to apply masks
10518            // because the unmasked parts will be overwritten by fields.
10519            // Write the fields.
10520            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            // Verify that padding bytes are zero.
10546            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            // Delegate to tuple encoding.
10593            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            // Zero out padding regions. There's no need to apply masks
10617            // because the unmasked parts will be overwritten by fields.
10618            // Write the fields.
10619            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            // Verify that padding bytes are zero.
10646            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                // Copy the object into the buffer.
10709                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10713                // done second because the memcpy will write garbage to these bytes.
10714            }
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            // Zero out padding regions. There's no need to apply masks
10733            // because the unmasked parts will be overwritten by fields.
10734            // Write the fields.
10735            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            // Verify that padding bytes are zero.
10760            // Copy from the buffer into the object.
10761            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            // Delegate to tuple encoding.
10799            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            // Zero out padding regions. There's no need to apply masks
10821            // because the unmasked parts will be overwritten by fields.
10822            // Write the fields.
10823            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            // Verify that padding bytes are zero.
10843            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            // Delegate to tuple encoding.
10888            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            // Zero out padding regions. There's no need to apply masks
10920            // because the unmasked parts will be overwritten by fields.
10921            // Write the fields.
10922            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            // Verify that padding bytes are zero.
10948            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            // Delegate to tuple encoding.
11002            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            // Zero out padding regions. There's no need to apply masks
11030            // because the unmasked parts will be overwritten by fields.
11031            unsafe {
11032                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11033                (ptr as *mut u64).write_unaligned(0);
11034            }
11035            // Write the fields.
11036            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            // Verify that padding bytes are zero.
11064            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                // Copy the object into the buffer.
11126                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11132                // done second because the memcpy will write garbage to these bytes.
11133            }
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            // Zero out padding regions. There's no need to apply masks
11154            // because the unmasked parts will be overwritten by fields.
11155            // Write the fields.
11156            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            // Verify that padding bytes are zero.
11180            // Copy from the buffer into the object.
11181            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            // Delegate to tuple encoding.
11219            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            // Zero out padding regions. There's no need to apply masks
11249            // because the unmasked parts will be overwritten by fields.
11250            // Write the fields.
11251            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            // Verify that padding bytes are zero.
11275            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            // Delegate to tuple encoding.
11328            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            // Zero out padding regions. There's no need to apply masks
11360            // because the unmasked parts will be overwritten by fields.
11361            // Write the fields.
11362            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            // Verify that padding bytes are zero.
11392            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                // Copy the object into the buffer.
11445                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11450                // done second because the memcpy will write garbage to these bytes.
11451            }
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            // Zero out padding regions. There's no need to apply masks
11467            // because the unmasked parts will be overwritten by fields.
11468            // Write the fields.
11469            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            // Verify that padding bytes are zero.
11492            // Copy from the buffer into the object.
11493            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                // Copy the object into the buffer.
11534                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11538                // done second because the memcpy will write garbage to these bytes.
11539                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            // Zero out padding regions. There's no need to apply masks
11569            // because the unmasked parts will be overwritten by fields.
11570            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            // Write the fields.
11579            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            // Verify that padding bytes are zero.
11614            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            // Copy from the buffer into the object.
11633            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            // Delegate to tuple encoding.
11674            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            // Zero out padding regions. There's no need to apply masks
11702            // because the unmasked parts will be overwritten by fields.
11703            unsafe {
11704                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11705                (ptr as *mut u64).write_unaligned(0);
11706            }
11707            // Write the fields.
11708            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            // Verify that padding bytes are zero.
11736            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                // Copy the object into the buffer.
11801                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11808                // done second because the memcpy will write garbage to these bytes.
11809            }
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            // Zero out padding regions. There's no need to apply masks
11829            // because the unmasked parts will be overwritten by fields.
11830            // Write the fields.
11831            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            // Verify that padding bytes are zero.
11854            // Copy from the buffer into the object.
11855            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                // Copy the object into the buffer.
11907                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11914                // done second because the memcpy will write garbage to these bytes.
11915            }
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            // Zero out padding regions. There's no need to apply masks
11932            // because the unmasked parts will be overwritten by fields.
11933            // Write the fields.
11934            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            // Verify that padding bytes are zero.
11957            // Copy from the buffer into the object.
11958            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            // Delegate to tuple encoding.
11999            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            // Zero out padding regions. There's no need to apply masks
12021            // because the unmasked parts will be overwritten by fields.
12022            // Write the fields.
12023            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            // Verify that padding bytes are zero.
12045            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            // Delegate to tuple encoding.
12091            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            // Zero out padding regions. There's no need to apply masks
12115            // because the unmasked parts will be overwritten by fields.
12116            // Write the fields.
12117            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            // Verify that padding bytes are zero.
12139            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            // Delegate to tuple encoding.
12185            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            // Zero out padding regions. There's no need to apply masks
12209            // because the unmasked parts will be overwritten by fields.
12210            // Write the fields.
12211            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            // Verify that padding bytes are zero.
12233            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            // Delegate to tuple encoding.
12279            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            // Zero out padding regions. There's no need to apply masks
12305            // because the unmasked parts will be overwritten by fields.
12306            unsafe {
12307                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12308                (ptr as *mut u64).write_unaligned(0);
12309            }
12310            // Write the fields.
12311            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            // Verify that padding bytes are zero.
12337            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            // Delegate to tuple encoding.
12386            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            // Zero out padding regions. There's no need to apply masks
12408            // because the unmasked parts will be overwritten by fields.
12409            // Write the fields.
12410            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            // Verify that padding bytes are zero.
12432            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            // Delegate to tuple encoding.
12478            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            // Zero out padding regions. There's no need to apply masks
12506            // because the unmasked parts will be overwritten by fields.
12507            unsafe {
12508                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
12509                (ptr as *mut u64).write_unaligned(0);
12510            }
12511            // Write the fields.
12512            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            // Verify that padding bytes are zero.
12540            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            // Delegate to tuple encoding.
12590            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            // Zero out padding regions. There's no need to apply masks
12616            // because the unmasked parts will be overwritten by fields.
12617            unsafe {
12618                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12619                (ptr as *mut u64).write_unaligned(0);
12620            }
12621            // Write the fields.
12622            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            // Verify that padding bytes are zero.
12648            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                // Copy the object into the buffer.
12707                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
12712                // done second because the memcpy will write garbage to these bytes.
12713            }
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            // Zero out padding regions. There's no need to apply masks
12729            // because the unmasked parts will be overwritten by fields.
12730            // Write the fields.
12731            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            // Verify that padding bytes are zero.
12754            // Copy from the buffer into the object.
12755            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            // Delegate to tuple encoding.
12796            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            // Zero out padding regions. There's no need to apply masks
12824            // because the unmasked parts will be overwritten by fields.
12825            // Write the fields.
12826            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            // Verify that padding bytes are zero.
12852            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            // Delegate to tuple encoding.
12892            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            // Zero out padding regions. There's no need to apply masks
12912            // because the unmasked parts will be overwritten by fields.
12913            // Write the fields.
12914            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            // Verify that padding bytes are zero.
12936            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            // Delegate to tuple encoding.
12975            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            // Zero out padding regions. There's no need to apply masks
12997            // because the unmasked parts will be overwritten by fields.
12998            // Write the fields.
12999            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            // Verify that padding bytes are zero.
13021            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                // Copy the object into the buffer.
13068                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13072                // done second because the memcpy will write garbage to these bytes.
13073                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            // Zero out padding regions. There's no need to apply masks
13095            // because the unmasked parts will be overwritten by fields.
13096            // Write the fields.
13097            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            // Verify that padding bytes are zero.
13120            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            // Copy from the buffer into the object.
13139            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                // Copy the object into the buffer.
13180                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13184                // done second because the memcpy will write garbage to these bytes.
13185                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            // Zero out padding regions. There's no need to apply masks
13207            // because the unmasked parts will be overwritten by fields.
13208            // Write the fields.
13209            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            // Verify that padding bytes are zero.
13232            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            // Copy from the buffer into the object.
13251            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                // Copy the object into the buffer.
13293                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13297                // done second because the memcpy will write garbage to these bytes.
13298                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            // Zero out padding regions. There's no need to apply masks
13320            // because the unmasked parts will be overwritten by fields.
13321            // Write the fields.
13322            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            // Verify that padding bytes are zero.
13345            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            // Copy from the buffer into the object.
13364            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                // Copy the object into the buffer.
13406                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13410                // done second because the memcpy will write garbage to these bytes.
13411                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            // Zero out padding regions. There's no need to apply masks
13433            // because the unmasked parts will be overwritten by fields.
13434            // Write the fields.
13435            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            // Verify that padding bytes are zero.
13458            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            // Copy from the buffer into the object.
13477            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            // Delegate to tuple encoding.
13517            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            // Zero out padding regions. There's no need to apply masks
13546            // because the unmasked parts will be overwritten by fields.
13547            // Write the fields.
13548            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            // Verify that padding bytes are zero.
13577            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                // Copy the object into the buffer.
13706                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13710                // done second because the memcpy will write garbage to these bytes.
13711            }
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            // Zero out padding regions. There's no need to apply masks
13730            // because the unmasked parts will be overwritten by fields.
13731            // Write the fields.
13732            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            // Verify that padding bytes are zero.
13757            // Copy from the buffer into the object.
13758            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                // Copy the object into the buffer.
13866                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                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13870                // done second because the memcpy will write garbage to these bytes.
13871            }
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            // Zero out padding regions. There's no need to apply masks
13892            // because the unmasked parts will be overwritten by fields.
13893            // Write the fields.
13894            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            // Verify that padding bytes are zero.
13923            // Copy from the buffer into the object.
13924            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            // Delegate to tuple encoding.
13965            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            // Zero out padding regions. There's no need to apply masks
13991            // because the unmasked parts will be overwritten by fields.
13992            unsafe {
13993                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
13994                (ptr as *mut u32).write_unaligned(0);
13995            }
13996            // Write the fields.
13997            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            // Verify that padding bytes are zero.
14020            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            // Delegate to tuple encoding.
14069            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            // Zero out padding regions. There's no need to apply masks
14095            // because the unmasked parts will be overwritten by fields.
14096            // Write the fields.
14097            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            // Verify that padding bytes are zero.
14120            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            // Delegate to tuple encoding.
14160            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            // Zero out padding regions. There's no need to apply masks
14186            // because the unmasked parts will be overwritten by fields.
14187            // Write the fields.
14188            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            // Verify that padding bytes are zero.
14211            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            // Delegate to tuple encoding.
14250            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            // Zero out padding regions. There's no need to apply masks
14288            // because the unmasked parts will be overwritten by fields.
14289            // Write the fields.
14290            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            // Verify that padding bytes are zero.
14328            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            // Delegate to tuple encoding.
14395            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            // Zero out padding regions. There's no need to apply masks
14477            // because the unmasked parts will be overwritten by fields.
14478            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            // Write the fields.
14487            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            // Verify that padding bytes are zero.
14549            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            // Vector header
14742            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            // Calling encoder.out_of_line_offset(0) is not allowed.
14746            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            // Calling decoder.out_of_line_offset(0) is not allowed.
14780            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            // Decode the envelope for each type.
14788            let mut _next_ordinal_to_read = 0;
14789            let mut next_offset = offset;
14790            let end_offset = offset + bytes_len;
14791
14792            // Decode the remaining unknown envelopes.
14793            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            // Vector header
14842            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            // Calling encoder.out_of_line_offset(0) is not allowed.
14846            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            // Calling decoder.out_of_line_offset(0) is not allowed.
14880            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            // Decode the envelope for each type.
14888            let mut _next_ordinal_to_read = 0;
14889            let mut next_offset = offset;
14890            let end_offset = offset + bytes_len;
14891
14892            // Decode the remaining unknown envelopes.
14893            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            // Vector header
14954            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            // Calling encoder.out_of_line_offset(0) is not allowed.
14958            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14972            // are envelope_size bytes.
14973            let cur_offset: usize = (1 - 1) * envelope_size;
14974
14975            // Zero reserved fields.
14976            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14977
14978            // Safety:
14979            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14980            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14981            //   envelope_size bytes, there is always sufficient room.
14982            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14997            // are envelope_size bytes.
14998            let cur_offset: usize = (2 - 1) * envelope_size;
14999
15000            // Zero reserved fields.
15001            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15002
15003            // Safety:
15004            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15005            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15006            //   envelope_size bytes, there is always sufficient room.
15007            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15022            // are envelope_size bytes.
15023            let cur_offset: usize = (3 - 1) * envelope_size;
15024
15025            // Zero reserved fields.
15026            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15027
15028            // Safety:
15029            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15030            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15031            //   envelope_size bytes, there is always sufficient room.
15032            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15045            // are envelope_size bytes.
15046            let cur_offset: usize = (4 - 1) * envelope_size;
15047
15048            // Zero reserved fields.
15049            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15050
15051            // Safety:
15052            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15053            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15054            //   envelope_size bytes, there is always sufficient room.
15055            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            // Calling decoder.out_of_line_offset(0) is not allowed.
15086            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            // Decode the envelope for each type.
15094            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            // Decode unknown envelopes for gaps in ordinals.
15103            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            // Decode unknown envelopes for gaps in ordinals.
15149            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            // Decode unknown envelopes for gaps in ordinals.
15194            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            // Decode unknown envelopes for gaps in ordinals.
15237            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            // Decode the remaining unknown envelopes.
15276            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            // Vector header
15325            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            // Calling encoder.out_of_line_offset(0) is not allowed.
15329            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            // Calling decoder.out_of_line_offset(0) is not allowed.
15361            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            // Decode the envelope for each type.
15369            let mut _next_ordinal_to_read = 0;
15370            let mut next_offset = offset;
15371            let end_offset = offset + bytes_len;
15372
15373            // Decode the remaining unknown envelopes.
15374            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            // Vector header
15426            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            // Calling encoder.out_of_line_offset(0) is not allowed.
15430            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15444            // are envelope_size bytes.
15445            let cur_offset: usize = (1 - 1) * envelope_size;
15446
15447            // Zero reserved fields.
15448            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15449
15450            // Safety:
15451            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15452            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15453            //   envelope_size bytes, there is always sufficient room.
15454            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            // Calling decoder.out_of_line_offset(0) is not allowed.
15487            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            // Decode the envelope for each type.
15495            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            // Decode unknown envelopes for gaps in ordinals.
15504            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            // Decode the remaining unknown envelopes.
15544            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            // Vector header
15608            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            // Calling encoder.out_of_line_offset(0) is not allowed.
15612            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15626            // are envelope_size bytes.
15627            let cur_offset: usize = (3 - 1) * envelope_size;
15628
15629            // Zero reserved fields.
15630            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15631
15632            // Safety:
15633            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15634            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15635            //   envelope_size bytes, there is always sufficient room.
15636            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15651            // are envelope_size bytes.
15652            let cur_offset: usize = (4 - 1) * envelope_size;
15653
15654            // Zero reserved fields.
15655            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15656
15657            // Safety:
15658            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15659            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15660            //   envelope_size bytes, there is always sufficient room.
15661            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15672            // are envelope_size bytes.
15673            let cur_offset: usize = (5 - 1) * envelope_size;
15674
15675            // Zero reserved fields.
15676            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15677
15678            // Safety:
15679            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15680            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15681            //   envelope_size bytes, there is always sufficient room.
15682            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15697            // are envelope_size bytes.
15698            let cur_offset: usize = (6 - 1) * envelope_size;
15699
15700            // Zero reserved fields.
15701            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15702
15703            // Safety:
15704            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15705            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15706            //   envelope_size bytes, there is always sufficient room.
15707            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15722            // are envelope_size bytes.
15723            let cur_offset: usize = (8 - 1) * envelope_size;
15724
15725            // Zero reserved fields.
15726            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15727
15728            // Safety:
15729            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15730            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15731            //   envelope_size bytes, there is always sufficient room.
15732            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            // Calling decoder.out_of_line_offset(0) is not allowed.
15765            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            // Decode the envelope for each type.
15773            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            // Decode unknown envelopes for gaps in ordinals.
15782            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            // Decode unknown envelopes for gaps in ordinals.
15829            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            // Decode unknown envelopes for gaps in ordinals.
15880            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            // Decode unknown envelopes for gaps in ordinals.
15924            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            // Decode unknown envelopes for gaps in ordinals.
15978            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            // Decode the remaining unknown envelopes.
16021            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            // Vector header
16094            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            // Calling encoder.out_of_line_offset(0) is not allowed.
16098            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16112            // are envelope_size bytes.
16113            let cur_offset: usize = (1 - 1) * envelope_size;
16114
16115            // Zero reserved fields.
16116            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16117
16118            // Safety:
16119            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16120            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16121            //   envelope_size bytes, there is always sufficient room.
16122            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16137            // are envelope_size bytes.
16138            let cur_offset: usize = (2 - 1) * envelope_size;
16139
16140            // Zero reserved fields.
16141            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16142
16143            // Safety:
16144            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16145            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16146            //   envelope_size bytes, there is always sufficient room.
16147            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16162            // are envelope_size bytes.
16163            let cur_offset: usize = (3 - 1) * envelope_size;
16164
16165            // Zero reserved fields.
16166            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16167
16168            // Safety:
16169            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16170            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16171            //   envelope_size bytes, there is always sufficient room.
16172            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16183            // are envelope_size bytes.
16184            let cur_offset: usize = (4 - 1) * envelope_size;
16185
16186            // Zero reserved fields.
16187            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16188
16189            // Safety:
16190            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16191            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16192            //   envelope_size bytes, there is always sufficient room.
16193            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16206            // are envelope_size bytes.
16207            let cur_offset: usize = (5 - 1) * envelope_size;
16208
16209            // Zero reserved fields.
16210            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16211
16212            // Safety:
16213            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16214            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16215            //   envelope_size bytes, there is always sufficient room.
16216            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16227            // are envelope_size bytes.
16228            let cur_offset: usize = (6 - 1) * envelope_size;
16229
16230            // Zero reserved fields.
16231            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16232
16233            // Safety:
16234            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16235            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16236            //   envelope_size bytes, there is always sufficient room.
16237            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16252            // are envelope_size bytes.
16253            let cur_offset: usize = (7 - 1) * envelope_size;
16254
16255            // Zero reserved fields.
16256            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16257
16258            // Safety:
16259            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16260            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16261            //   envelope_size bytes, there is always sufficient room.
16262            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16275            // are envelope_size bytes.
16276            let cur_offset: usize = (8 - 1) * envelope_size;
16277
16278            // Zero reserved fields.
16279            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16280
16281            // Safety:
16282            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16283            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16284            //   envelope_size bytes, there is always sufficient room.
16285            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            // Calling decoder.out_of_line_offset(0) is not allowed.
16318            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            // Decode the envelope for each type.
16326            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            // Decode unknown envelopes for gaps in ordinals.
16335            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            // Decode unknown envelopes for gaps in ordinals.
16380            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            // Decode unknown envelopes for gaps in ordinals.
16434            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            // Decode unknown envelopes for gaps in ordinals.
16485            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            // Decode unknown envelopes for gaps in ordinals.
16528            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            // Decode unknown envelopes for gaps in ordinals.
16579            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            // Decode unknown envelopes for gaps in ordinals.
16624            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            // Decode unknown envelopes for gaps in ordinals.
16667            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            // Decode the remaining unknown envelopes.
16706            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            // Vector header
16776            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            // Calling encoder.out_of_line_offset(0) is not allowed.
16780            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16794            // are envelope_size bytes.
16795            let cur_offset: usize = (1 - 1) * envelope_size;
16796
16797            // Zero reserved fields.
16798            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16799
16800            // Safety:
16801            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16802            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16803            //   envelope_size bytes, there is always sufficient room.
16804            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16817            // are envelope_size bytes.
16818            let cur_offset: usize = (2 - 1) * envelope_size;
16819
16820            // Zero reserved fields.
16821            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16822
16823            // Safety:
16824            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16825            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16826            //   envelope_size bytes, there is always sufficient room.
16827            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16840            // are envelope_size bytes.
16841            let cur_offset: usize = (3 - 1) * envelope_size;
16842
16843            // Zero reserved fields.
16844            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16845
16846            // Safety:
16847            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16848            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16849            //   envelope_size bytes, there is always sufficient room.
16850            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16863            // are envelope_size bytes.
16864            let cur_offset: usize = (4 - 1) * envelope_size;
16865
16866            // Zero reserved fields.
16867            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16868
16869            // Safety:
16870            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16871            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16872            //   envelope_size bytes, there is always sufficient room.
16873            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16888            // are envelope_size bytes.
16889            let cur_offset: usize = (5 - 1) * envelope_size;
16890
16891            // Zero reserved fields.
16892            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16893
16894            // Safety:
16895            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16896            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16897            //   envelope_size bytes, there is always sufficient room.
16898            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16911            // are envelope_size bytes.
16912            let cur_offset: usize = (6 - 1) * envelope_size;
16913
16914            // Zero reserved fields.
16915            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16916
16917            // Safety:
16918            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16919            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16920            //   envelope_size bytes, there is always sufficient room.
16921            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16936            // are envelope_size bytes.
16937            let cur_offset: usize = (7 - 1) * envelope_size;
16938
16939            // Zero reserved fields.
16940            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16941
16942            // Safety:
16943            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16944            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16945            //   envelope_size bytes, there is always sufficient room.
16946            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            // Calling decoder.out_of_line_offset(0) is not allowed.
16979            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            // Decode the envelope for each type.
16987            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            // Decode unknown envelopes for gaps in ordinals.
16996            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            // Decode unknown envelopes for gaps in ordinals.
17039            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            // Decode unknown envelopes for gaps in ordinals.
17082            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            // Decode unknown envelopes for gaps in ordinals.
17125            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            // Decode unknown envelopes for gaps in ordinals.
17169            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            // Decode unknown envelopes for gaps in ordinals.
17212            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            // Decode unknown envelopes for gaps in ordinals.
17255            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            // Decode the remaining unknown envelopes.
17305            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            // Vector header
17372            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            // Calling encoder.out_of_line_offset(0) is not allowed.
17376            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17390            // are envelope_size bytes.
17391            let cur_offset: usize = (1 - 1) * envelope_size;
17392
17393            // Zero reserved fields.
17394            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17395
17396            // Safety:
17397            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17398            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17399            //   envelope_size bytes, there is always sufficient room.
17400            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17413            // are envelope_size bytes.
17414            let cur_offset: usize = (2 - 1) * envelope_size;
17415
17416            // Zero reserved fields.
17417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17418
17419            // Safety:
17420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17422            //   envelope_size bytes, there is always sufficient room.
17423            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17436            // are envelope_size bytes.
17437            let cur_offset: usize = (3 - 1) * envelope_size;
17438
17439            // Zero reserved fields.
17440            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17441
17442            // Safety:
17443            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17444            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17445            //   envelope_size bytes, there is always sufficient room.
17446            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17459            // are envelope_size bytes.
17460            let cur_offset: usize = (4 - 1) * envelope_size;
17461
17462            // Zero reserved fields.
17463            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17464
17465            // Safety:
17466            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17467            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17468            //   envelope_size bytes, there is always sufficient room.
17469            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17482            // are envelope_size bytes.
17483            let cur_offset: usize = (5 - 1) * envelope_size;
17484
17485            // Zero reserved fields.
17486            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17487
17488            // Safety:
17489            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17490            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17491            //   envelope_size bytes, there is always sufficient room.
17492            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17505            // are envelope_size bytes.
17506            let cur_offset: usize = (6 - 1) * envelope_size;
17507
17508            // Zero reserved fields.
17509            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17510
17511            // Safety:
17512            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17513            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17514            //   envelope_size bytes, there is always sufficient room.
17515            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            // Calling decoder.out_of_line_offset(0) is not allowed.
17548            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            // Decode the envelope for each type.
17556            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            // Decode unknown envelopes for gaps in ordinals.
17565            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            // Decode unknown envelopes for gaps in ordinals.
17608            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            // Decode unknown envelopes for gaps in ordinals.
17651            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            // Decode unknown envelopes for gaps in ordinals.
17694            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            // Decode unknown envelopes for gaps in ordinals.
17737            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            // Decode unknown envelopes for gaps in ordinals.
17780            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            // Decode the remaining unknown envelopes.
17819            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            // Vector header
17877            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            // Calling encoder.out_of_line_offset(0) is not allowed.
17881            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17895            // are envelope_size bytes.
17896            let cur_offset: usize = (1 - 1) * envelope_size;
17897
17898            // Zero reserved fields.
17899            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17900
17901            // Safety:
17902            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17903            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17904            //   envelope_size bytes, there is always sufficient room.
17905            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17918            // are envelope_size bytes.
17919            let cur_offset: usize = (2 - 1) * envelope_size;
17920
17921            // Zero reserved fields.
17922            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17923
17924            // Safety:
17925            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17926            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17927            //   envelope_size bytes, there is always sufficient room.
17928            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17941            // are envelope_size bytes.
17942            let cur_offset: usize = (3 - 1) * envelope_size;
17943
17944            // Zero reserved fields.
17945            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17946
17947            // Safety:
17948            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17949            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17950            //   envelope_size bytes, there is always sufficient room.
17951            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            // Calling decoder.out_of_line_offset(0) is not allowed.
17982            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            // Decode the envelope for each type.
17990            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            // Decode unknown envelopes for gaps in ordinals.
17999            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            // Decode unknown envelopes for gaps in ordinals.
18042            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            // Decode unknown envelopes for gaps in ordinals.
18085            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            // Decode the remaining unknown envelopes.
18124            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            // Vector header
18180            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            // Calling encoder.out_of_line_offset(0) is not allowed.
18184            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18198            // are envelope_size bytes.
18199            let cur_offset: usize = (1 - 1) * envelope_size;
18200
18201            // Zero reserved fields.
18202            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18203
18204            // Safety:
18205            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18206            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18207            //   envelope_size bytes, there is always sufficient room.
18208            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18223            // are envelope_size bytes.
18224            let cur_offset: usize = (2 - 1) * envelope_size;
18225
18226            // Zero reserved fields.
18227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18228
18229            // Safety:
18230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18232            //   envelope_size bytes, there is always sufficient room.
18233            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            // Calling decoder.out_of_line_offset(0) is not allowed.
18268            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            // Decode the envelope for each type.
18276            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            // Decode unknown envelopes for gaps in ordinals.
18285            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            // Decode unknown envelopes for gaps in ordinals.
18329            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            // Decode the remaining unknown envelopes.
18371            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            // Vector header
18426            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            // Calling encoder.out_of_line_offset(0) is not allowed.
18430            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18444            // are envelope_size bytes.
18445            let cur_offset: usize = (1 - 1) * envelope_size;
18446
18447            // Zero reserved fields.
18448            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18449
18450            // Safety:
18451            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18452            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18453            //   envelope_size bytes, there is always sufficient room.
18454            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18467            // are envelope_size bytes.
18468            let cur_offset: usize = (2 - 1) * envelope_size;
18469
18470            // Zero reserved fields.
18471            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18472
18473            // Safety:
18474            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18475            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18476            //   envelope_size bytes, there is always sufficient room.
18477            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            // Calling decoder.out_of_line_offset(0) is not allowed.
18510            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            // Decode the envelope for each type.
18518            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            // Decode unknown envelopes for gaps in ordinals.
18527            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            // Decode unknown envelopes for gaps in ordinals.
18570            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            // Decode the remaining unknown envelopes.
18611            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            // Vector header
18661            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            // Calling encoder.out_of_line_offset(0) is not allowed.
18665            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            // Calling decoder.out_of_line_offset(0) is not allowed.
18699            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            // Decode the envelope for each type.
18707            let mut _next_ordinal_to_read = 0;
18708            let mut next_offset = offset;
18709            let end_offset = offset + bytes_len;
18710
18711            // Decode the remaining unknown envelopes.
18712            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            // Vector header
18761            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            // Calling encoder.out_of_line_offset(0) is not allowed.
18765            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            // Calling decoder.out_of_line_offset(0) is not allowed.
18797            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            // Decode the envelope for each type.
18805            let mut _next_ordinal_to_read = 0;
18806            let mut next_offset = offset;
18807            let end_offset = offset + bytes_len;
18808
18809            // Decode the remaining unknown envelopes.
18810            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            // Vector header
18884            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            // Calling encoder.out_of_line_offset(0) is not allowed.
18888            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18902            // are envelope_size bytes.
18903            let cur_offset: usize = (1 - 1) * envelope_size;
18904
18905            // Zero reserved fields.
18906            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18907
18908            // Safety:
18909            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18910            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18911            //   envelope_size bytes, there is always sufficient room.
18912            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18925            // are envelope_size bytes.
18926            let cur_offset: usize = (2 - 1) * envelope_size;
18927
18928            // Zero reserved fields.
18929            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18930
18931            // Safety:
18932            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18933            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18934            //   envelope_size bytes, there is always sufficient room.
18935            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18948            // are envelope_size bytes.
18949            let cur_offset: usize = (3 - 1) * envelope_size;
18950
18951            // Zero reserved fields.
18952            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18953
18954            // Safety:
18955            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18956            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18957            //   envelope_size bytes, there is always sufficient room.
18958            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18973            // are envelope_size bytes.
18974            let cur_offset: usize = (4 - 1) * envelope_size;
18975
18976            // Zero reserved fields.
18977            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18978
18979            // Safety:
18980            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18981            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18982            //   envelope_size bytes, there is always sufficient room.
18983            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18996            // are envelope_size bytes.
18997            let cur_offset: usize = (5 - 1) * envelope_size;
18998
18999            // Zero reserved fields.
19000            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19001
19002            // Safety:
19003            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19004            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19005            //   envelope_size bytes, there is always sufficient room.
19006            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19021            // are envelope_size bytes.
19022            let cur_offset: usize = (6 - 1) * envelope_size;
19023
19024            // Zero reserved fields.
19025            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19026
19027            // Safety:
19028            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19029            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19030            //   envelope_size bytes, there is always sufficient room.
19031            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19044            // are envelope_size bytes.
19045            let cur_offset: usize = (7 - 1) * envelope_size;
19046
19047            // Zero reserved fields.
19048            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19049
19050            // Safety:
19051            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19052            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19053            //   envelope_size bytes, there is always sufficient room.
19054            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19069            // are envelope_size bytes.
19070            let cur_offset: usize = (8 - 1) * envelope_size;
19071
19072            // Zero reserved fields.
19073            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19074
19075            // Safety:
19076            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19077            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19078            //   envelope_size bytes, there is always sufficient room.
19079            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19094            // are envelope_size bytes.
19095            let cur_offset: usize = (9 - 1) * envelope_size;
19096
19097            // Zero reserved fields.
19098            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19099
19100            // Safety:
19101            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19102            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19103            //   envelope_size bytes, there is always sufficient room.
19104            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            // Calling decoder.out_of_line_offset(0) is not allowed.
19135            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            // Decode the envelope for each type.
19143            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            // Decode unknown envelopes for gaps in ordinals.
19152            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            // Decode unknown envelopes for gaps in ordinals.
19195            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            // Decode unknown envelopes for gaps in ordinals.
19238            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            // Decode unknown envelopes for gaps in ordinals.
19282            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            // Decode unknown envelopes for gaps in ordinals.
19325            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            // Decode unknown envelopes for gaps in ordinals.
19369            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            // Decode unknown envelopes for gaps in ordinals.
19412            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            // Decode unknown envelopes for gaps in ordinals.
19456            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            // Decode unknown envelopes for gaps in ordinals.
19500            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            // Decode the remaining unknown envelopes.
19539            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            // Vector header
19594            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            // Calling encoder.out_of_line_offset(0) is not allowed.
19598            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19612            // are envelope_size bytes.
19613            let cur_offset: usize = (1 - 1) * envelope_size;
19614
19615            // Zero reserved fields.
19616            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19617
19618            // Safety:
19619            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19620            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19621            //   envelope_size bytes, there is always sufficient room.
19622            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19637            // are envelope_size bytes.
19638            let cur_offset: usize = (2 - 1) * envelope_size;
19639
19640            // Zero reserved fields.
19641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19642
19643            // Safety:
19644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19646            //   envelope_size bytes, there is always sufficient room.
19647            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            // Calling decoder.out_of_line_offset(0) is not allowed.
19678            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            // Decode the envelope for each type.
19686            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            // Decode unknown envelopes for gaps in ordinals.
19695            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            // Decode unknown envelopes for gaps in ordinals.
19739            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            // Decode the remaining unknown envelopes.
19778            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            // Vector header
19866            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            // Calling encoder.out_of_line_offset(0) is not allowed.
19870            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19884            // are envelope_size bytes.
19885            let cur_offset: usize = (1 - 1) * envelope_size;
19886
19887            // Zero reserved fields.
19888            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19889
19890            // Safety:
19891            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19892            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19893            //   envelope_size bytes, there is always sufficient room.
19894            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19909            // are envelope_size bytes.
19910            let cur_offset: usize = (2 - 1) * envelope_size;
19911
19912            // Zero reserved fields.
19913            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19914
19915            // Safety:
19916            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19917            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19918            //   envelope_size bytes, there is always sufficient room.
19919            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19934            // are envelope_size bytes.
19935            let cur_offset: usize = (3 - 1) * envelope_size;
19936
19937            // Zero reserved fields.
19938            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19939
19940            // Safety:
19941            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19942            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19943            //   envelope_size bytes, there is always sufficient room.
19944            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19959            // are envelope_size bytes.
19960            let cur_offset: usize = (4 - 1) * envelope_size;
19961
19962            // Zero reserved fields.
19963            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19964
19965            // Safety:
19966            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19967            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19968            //   envelope_size bytes, there is always sufficient room.
19969            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19984            // are envelope_size bytes.
19985            let cur_offset: usize = (5 - 1) * envelope_size;
19986
19987            // Zero reserved fields.
19988            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19989
19990            // Safety:
19991            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19992            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19993            //   envelope_size bytes, there is always sufficient room.
19994            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20009            // are envelope_size bytes.
20010            let cur_offset: usize = (6 - 1) * envelope_size;
20011
20012            // Zero reserved fields.
20013            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20014
20015            // Safety:
20016            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20017            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20018            //   envelope_size bytes, there is always sufficient room.
20019            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20034            // are envelope_size bytes.
20035            let cur_offset: usize = (7 - 1) * envelope_size;
20036
20037            // Zero reserved fields.
20038            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20039
20040            // Safety:
20041            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20042            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20043            //   envelope_size bytes, there is always sufficient room.
20044            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20059            // are envelope_size bytes.
20060            let cur_offset: usize = (8 - 1) * envelope_size;
20061
20062            // Zero reserved fields.
20063            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20064
20065            // Safety:
20066            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20067            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20068            //   envelope_size bytes, there is always sufficient room.
20069            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20084            // are envelope_size bytes.
20085            let cur_offset: usize = (9 - 1) * envelope_size;
20086
20087            // Zero reserved fields.
20088            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20089
20090            // Safety:
20091            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20092            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20093            //   envelope_size bytes, there is always sufficient room.
20094            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20109            // are envelope_size bytes.
20110            let cur_offset: usize = (10 - 1) * envelope_size;
20111
20112            // Zero reserved fields.
20113            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20114
20115            // Safety:
20116            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20117            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20118            //   envelope_size bytes, there is always sufficient room.
20119            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20134            // are envelope_size bytes.
20135            let cur_offset: usize = (11 - 1) * envelope_size;
20136
20137            // Zero reserved fields.
20138            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20139
20140            // Safety:
20141            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20142            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20143            //   envelope_size bytes, there is always sufficient room.
20144            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20159            // are envelope_size bytes.
20160            let cur_offset: usize = (12 - 1) * envelope_size;
20161
20162            // Zero reserved fields.
20163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20164
20165            // Safety:
20166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20168            //   envelope_size bytes, there is always sufficient room.
20169            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20184            // are envelope_size bytes.
20185            let cur_offset: usize = (13 - 1) * envelope_size;
20186
20187            // Zero reserved fields.
20188            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20189
20190            // Safety:
20191            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20192            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20193            //   envelope_size bytes, there is always sufficient room.
20194            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            // Calling decoder.out_of_line_offset(0) is not allowed.
20229            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            // Decode the envelope for each type.
20237            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            // Decode unknown envelopes for gaps in ordinals.
20246            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            // Decode unknown envelopes for gaps in ordinals.
20291            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            // Decode unknown envelopes for gaps in ordinals.
20345            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            // Decode unknown envelopes for gaps in ordinals.
20390            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            // Decode unknown envelopes for gaps in ordinals.
20435            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            // Decode unknown envelopes for gaps in ordinals.
20480            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            // Decode unknown envelopes for gaps in ordinals.
20525            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            // Decode unknown envelopes for gaps in ordinals.
20570            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            // Decode unknown envelopes for gaps in ordinals.
20615            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            // Decode unknown envelopes for gaps in ordinals.
20660            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            // Decode unknown envelopes for gaps in ordinals.
20705            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            // Decode unknown envelopes for gaps in ordinals.
20750            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            // Decode unknown envelopes for gaps in ordinals.
20795            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            // Decode the remaining unknown envelopes.
20836            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            // Vector header
20903            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            // Calling encoder.out_of_line_offset(0) is not allowed.
20907            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20921            // are envelope_size bytes.
20922            let cur_offset: usize = (1 - 1) * envelope_size;
20923
20924            // Zero reserved fields.
20925            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20926
20927            // Safety:
20928            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20929            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20930            //   envelope_size bytes, there is always sufficient room.
20931            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20946            // are envelope_size bytes.
20947            let cur_offset: usize = (2 - 1) * envelope_size;
20948
20949            // Zero reserved fields.
20950            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20951
20952            // Safety:
20953            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20954            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20955            //   envelope_size bytes, there is always sufficient room.
20956            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20971            // are envelope_size bytes.
20972            let cur_offset: usize = (3 - 1) * envelope_size;
20973
20974            // Zero reserved fields.
20975            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20976
20977            // Safety:
20978            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20979            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20980            //   envelope_size bytes, there is always sufficient room.
20981            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20996            // are envelope_size bytes.
20997            let cur_offset: usize = (4 - 1) * envelope_size;
20998
20999            // Zero reserved fields.
21000            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21001
21002            // Safety:
21003            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21004            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21005            //   envelope_size bytes, there is always sufficient room.
21006            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21021            // are envelope_size bytes.
21022            let cur_offset: usize = (5 - 1) * envelope_size;
21023
21024            // Zero reserved fields.
21025            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21026
21027            // Safety:
21028            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21029            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21030            //   envelope_size bytes, there is always sufficient room.
21031            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21046            // are envelope_size bytes.
21047            let cur_offset: usize = (6 - 1) * envelope_size;
21048
21049            // Zero reserved fields.
21050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21051
21052            // Safety:
21053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21055            //   envelope_size bytes, there is always sufficient room.
21056            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            // Calling decoder.out_of_line_offset(0) is not allowed.
21089            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            // Decode the envelope for each type.
21097            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            // Decode unknown envelopes for gaps in ordinals.
21106            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            // Decode unknown envelopes for gaps in ordinals.
21150            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            // Decode unknown envelopes for gaps in ordinals.
21195            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            // Decode unknown envelopes for gaps in ordinals.
21239            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            // Decode unknown envelopes for gaps in ordinals.
21283            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            // Decode unknown envelopes for gaps in ordinals.
21327            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            // Decode the remaining unknown envelopes.
21367            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            // Vector header
21425            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            // Calling encoder.out_of_line_offset(0) is not allowed.
21429            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21443            // are envelope_size bytes.
21444            let cur_offset: usize = (1 - 1) * envelope_size;
21445
21446            // Zero reserved fields.
21447            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21448
21449            // Safety:
21450            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21451            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21452            //   envelope_size bytes, there is always sufficient room.
21453            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21468            // are envelope_size bytes.
21469            let cur_offset: usize = (2 - 1) * envelope_size;
21470
21471            // Zero reserved fields.
21472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21473
21474            // Safety:
21475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21477            //   envelope_size bytes, there is always sufficient room.
21478            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21493            // are envelope_size bytes.
21494            let cur_offset: usize = (3 - 1) * envelope_size;
21495
21496            // Zero reserved fields.
21497            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21498
21499            // Safety:
21500            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21501            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21502            //   envelope_size bytes, there is always sufficient room.
21503            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            // Calling decoder.out_of_line_offset(0) is not allowed.
21538            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            // Decode the envelope for each type.
21546            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            // Decode unknown envelopes for gaps in ordinals.
21555            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            // Decode unknown envelopes for gaps in ordinals.
21599            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            // Decode unknown envelopes for gaps in ordinals.
21644            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            // Decode the remaining unknown envelopes.
21694            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            // Vector header
21749            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            // Calling encoder.out_of_line_offset(0) is not allowed.
21753            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21767            // are envelope_size bytes.
21768            let cur_offset: usize = (1 - 1) * envelope_size;
21769
21770            // Zero reserved fields.
21771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21772
21773            // Safety:
21774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21776            //   envelope_size bytes, there is always sufficient room.
21777            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21792            // are envelope_size bytes.
21793            let cur_offset: usize = (2 - 1) * envelope_size;
21794
21795            // Zero reserved fields.
21796            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21797
21798            // Safety:
21799            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21800            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21801            //   envelope_size bytes, there is always sufficient room.
21802            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            // Calling decoder.out_of_line_offset(0) is not allowed.
21835            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            // Decode the envelope for each type.
21843            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            // Decode unknown envelopes for gaps in ordinals.
21852            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            // Decode unknown envelopes for gaps in ordinals.
21896            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            // Decode the remaining unknown envelopes.
21936            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            // Vector header
21985            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            // Calling encoder.out_of_line_offset(0) is not allowed.
21989            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            // Calling decoder.out_of_line_offset(0) is not allowed.
22021            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            // Decode the envelope for each type.
22029            let mut _next_ordinal_to_read = 0;
22030            let mut next_offset = offset;
22031            let end_offset = offset + bytes_len;
22032
22033            // Decode the remaining unknown envelopes.
22034            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            // Vector header
22083            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            // Calling encoder.out_of_line_offset(0) is not allowed.
22087            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            // Calling decoder.out_of_line_offset(0) is not allowed.
22119            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            // Decode the envelope for each type.
22127            let mut _next_ordinal_to_read = 0;
22128            let mut next_offset = offset;
22129            let end_offset = offset + bytes_len;
22130
22131            // Decode the remaining unknown envelopes.
22132            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            // Vector header
22181            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            // Calling encoder.out_of_line_offset(0) is not allowed.
22185            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            // Calling decoder.out_of_line_offset(0) is not allowed.
22217            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            // Decode the envelope for each type.
22225            let mut _next_ordinal_to_read = 0;
22226            let mut next_offset = offset;
22227            let end_offset = offset + bytes_len;
22228
22229            // Decode the remaining unknown envelopes.
22230            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                        // Do nothing, read the value into the object
22340                    } else {
22341                        // Initialize `self` to the right variant
22342                        *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                        // Do nothing, read the value into the object
22355                    } else {
22356                        // Initialize `self` to the right variant
22357                        *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                        // Do nothing, read the value into the object
22485                    } else {
22486                        // Initialize `self` to the right variant
22487                        *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                        // Do nothing, read the value into the object
22500                    } else {
22501                        // Initialize `self` to the right variant
22502                        *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                        // Do nothing, read the value into the object
22515                    } else {
22516                        // Initialize `self` to the right variant
22517                        *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                        // Do nothing, read the value into the object
22654                    } else {
22655                        // Initialize `self` to the right variant
22656                        *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                        // Do nothing, read the value into the object
22679                    } else {
22680                        // Initialize `self` to the right variant
22681                        *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                        // Do nothing, read the value into the object
22836                    } else {
22837                        // Initialize `self` to the right variant
22838                        *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                        // Do nothing, read the value into the object
22861                    } else {
22862                        // Initialize `self` to the right variant
22863                        *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                        // Do nothing, read the value into the object
22886                    } else {
22887                        // Initialize `self` to the right variant
22888                        *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                        // Do nothing, read the value into the object
22911                    } else {
22912                        // Initialize `self` to the right variant
22913                        *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                        // Do nothing, read the value into the object
23037                    } else {
23038                        // Initialize `self` to the right variant
23039                        *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                        // Do nothing, read the value into the object
23160                    } else {
23161                        // Initialize `self` to the right variant
23162                        *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                        // Do nothing, read the value into the object
23182                    } else {
23183                        // Initialize `self` to the right variant
23184                        *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                        // Do nothing, read the value into the object
23302                    } else {
23303                        // Initialize `self` to the right variant
23304                        *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                        // Do nothing, read the value into the object
23423                    } else {
23424                        // Initialize `self` to the right variant
23425                        *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                        // Do nothing, read the value into the object
23438                    } else {
23439                        // Initialize `self` to the right variant
23440                        *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                        // Do nothing, read the value into the object
23572                    } else {
23573                        // Initialize `self` to the right variant
23574                        *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                        // Do nothing, read the value into the object
23587                    } else {
23588                        // Initialize `self` to the right variant
23589                        *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                        // Do nothing, read the value into the object
23602                    } else {
23603                        // Initialize `self` to the right variant
23604                        *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                        // Do nothing, read the value into the object
23782                    } else {
23783                        // Initialize `self` to the right variant
23784                        *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                        // Do nothing, read the value into the object
23797                    } else {
23798                        // Initialize `self` to the right variant
23799                        *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                        // Do nothing, read the value into the object
23812                    } else {
23813                        // Initialize `self` to the right variant
23814                        *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                        // Do nothing, read the value into the object
23827                    } else {
23828                        // Initialize `self` to the right variant
23829                        *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                        // Do nothing, read the value into the object
23842                    } else {
23843                        // Initialize `self` to the right variant
23844                        *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                        // Do nothing, read the value into the object
23857                    } else {
23858                        // Initialize `self` to the right variant
23859                        *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                        // Do nothing, read the value into the object
23872                    } else {
23873                        // Initialize `self` to the right variant
23874                        *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                        // Do nothing, read the value into the object
24019                    } else {
24020                        // Initialize `self` to the right variant
24021                        *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                        // Do nothing, read the value into the object
24035                    } else {
24036                        // Initialize `self` to the right variant
24037                        *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                        // Do nothing, read the value into the object
24051                    } else {
24052                        // Initialize `self` to the right variant
24053                        *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                        // Do nothing, read the value into the object
24066                    } else {
24067                        // Initialize `self` to the right variant
24068                        *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                        // Do nothing, read the value into the object
24188                    } else {
24189                        // Initialize `self` to the right variant
24190                        *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                        // Do nothing, read the value into the object
24203                    } else {
24204                        // Initialize `self` to the right variant
24205                        *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                        // Do nothing, read the value into the object
24326                    } else {
24327                        // Initialize `self` to the right variant
24328                        *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                        // Do nothing, read the value into the object
24341                    } else {
24342                        // Initialize `self` to the right variant
24343                        *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                        // Do nothing, read the value into the object
24479                    } else {
24480                        // Initialize `self` to the right variant
24481                        *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                        // Do nothing, read the value into the object
24494                    } else {
24495                        // Initialize `self` to the right variant
24496                        *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                        // Do nothing, read the value into the object
24509                    } else {
24510                        // Initialize `self` to the right variant
24511                        *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                        // Do nothing, read the value into the object
24655                    } else {
24656                        // Initialize `self` to the right variant
24657                        *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                        // Do nothing, read the value into the object
24670                    } else {
24671                        // Initialize `self` to the right variant
24672                        *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                        // Do nothing, read the value into the object
24685                    } else {
24686                        // Initialize `self` to the right variant
24687                        *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                        // Do nothing, read the value into the object
24700                    } else {
24701                        // Initialize `self` to the right variant
24702                        *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                        // Do nothing, read the value into the object
24725                    } else {
24726                        // Initialize `self` to the right variant
24727                        *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                        // Do nothing, read the value into the object
24845                    } else {
24846                        // Initialize `self` to the right variant
24847                        *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                        // Do nothing, read the value into the object
24969                    } else {
24970                        // Initialize `self` to the right variant
24971                        *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                        // Do nothing, read the value into the object
24991                    } else {
24992                        // Initialize `self` to the right variant
24993                        *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}