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
3386pub mod activity_reporter_ordinals {
3387    pub const WATCH_RENDER_ACTIVITY: u64 = 0x2974e9f5880b2f1f;
3388    pub const WATCH_RENDER_ACTIVITY2: u64 = 0x484236fc11b363e6;
3389    pub const WATCH_CAPTURE_ACTIVITY: u64 = 0x70e7038e9658e128;
3390    pub const WATCH_CAPTURE_ACTIVITY2: u64 = 0x3d137e0364f9d550;
3391}
3392
3393pub mod audio_ordinals {
3394    pub const CREATE_AUDIO_RENDERER: u64 = 0x572f413566fd58f1;
3395    pub const CREATE_AUDIO_CAPTURER: u64 = 0x44660fc63a6202f;
3396}
3397
3398pub mod audio_capturer_ordinals {
3399    pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3400    pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3401    pub const ON_PACKET_PRODUCED: u64 = 0x6bbe69746a3c8bd9;
3402    pub const ON_END_OF_STREAM: u64 = 0x550e69b41d03e2c2;
3403    pub const RELEASE_PACKET: u64 = 0x7a7b57f0f7d9e4bb;
3404    pub const DISCARD_ALL_PACKETS: u64 = 0x27afd605e97b09d2;
3405    pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x35f9d721e905b831;
3406    pub const SET_PCM_STREAM_TYPE: u64 = 0x1531ea9ea2c852cd;
3407    pub const CAPTURE_AT: u64 = 0x784e25df72cea780;
3408    pub const START_ASYNC_CAPTURE: u64 = 0x7768adbb1ccfd7a6;
3409    pub const STOP_ASYNC_CAPTURE: u64 = 0x5bfc8790a8cef8cb;
3410    pub const STOP_ASYNC_CAPTURE_NO_REPLY: u64 = 0x33223cb2962c95e3;
3411    pub const BIND_GAIN_CONTROL: u64 = 0x658a6a17ddb3a8e0;
3412    pub const GET_REFERENCE_CLOCK: u64 = 0x50d037aa5a4b4d71;
3413    pub const SET_REFERENCE_CLOCK: u64 = 0x732b2c496d521bcf;
3414    pub const SET_USAGE: u64 = 0x42a16f392bd21b25;
3415    pub const SET_USAGE2: u64 = 0x7a73e251b8d2382b;
3416    pub const GET_STREAM_TYPE: u64 = 0x5dcaaa670b433088;
3417}
3418
3419pub mod audio_consumer_ordinals {
3420    pub const CREATE_STREAM_SINK: u64 = 0x525b3b97fdf7d884;
3421    pub const ON_END_OF_STREAM: u64 = 0x53a64e6d0e8f8a20;
3422    pub const START: u64 = 0x4fdbd44b3f2a3a3c;
3423    pub const STOP: u64 = 0x3d46c3741686c40d;
3424    pub const SET_RATE: u64 = 0x45342b73968bfafe;
3425    pub const BIND_VOLUME_CONTROL: u64 = 0x6f1b01fd887f5748;
3426    pub const WATCH_STATUS: u64 = 0x35cf702c721e2cc6;
3427}
3428
3429pub mod audio_core_ordinals {
3430    pub const CREATE_AUDIO_RENDERER: u64 = 0x2ac9beba47f83435;
3431    pub const CREATE_AUDIO_CAPTURER_WITH_CONFIGURATION: u64 = 0x459de383b0d76d97;
3432    pub const CREATE_AUDIO_CAPTURER: u64 = 0x787db169df99aed0;
3433    pub const ENABLE_DEVICE_SETTINGS: u64 = 0x41107a1917269b3e;
3434    pub const SET_RENDER_USAGE_GAIN: u64 = 0x48097f45f6e2b8e7;
3435    pub const SET_RENDER_USAGE_GAIN2: u64 = 0x779b1531dc9e64f4;
3436    pub const SET_CAPTURE_USAGE_GAIN: u64 = 0x457d29217d4ea248;
3437    pub const SET_CAPTURE_USAGE_GAIN2: u64 = 0x15065ee308f44af0;
3438    pub const BIND_USAGE_VOLUME_CONTROL: u64 = 0x7225be116aadc137;
3439    pub const BIND_USAGE_VOLUME_CONTROL2: u64 = 0x729dff93019d055;
3440    pub const GET_VOLUME_FROM_DB: u64 = 0x50e3ca45509770bf;
3441    pub const GET_VOLUME_FROM_DB2: u64 = 0x165c811091ef99da;
3442    pub const GET_DB_FROM_VOLUME: u64 = 0x3e8eec27dd5a8bda;
3443    pub const GET_DB_FROM_VOLUME2: u64 = 0x5f421a8ebf265bf3;
3444    pub const SET_INTERACTION: u64 = 0x7bfed14345ece7b7;
3445    pub const SET_INTERACTION2: u64 = 0x7226c7c6e6edc62f;
3446    pub const RESET_INTERACTIONS: u64 = 0x65bd94d9d0a28b5e;
3447    pub const LOAD_DEFAULTS: u64 = 0x54a0bebca85f6b31;
3448}
3449
3450pub mod audio_device_enumerator_ordinals {
3451    pub const GET_DEVICES: u64 = 0x4ce1aa218aeb12a6;
3452    pub const ON_DEVICE_ADDED: u64 = 0xe0fbe40057c4b44;
3453    pub const ON_DEVICE_REMOVED: u64 = 0x6f3b7574463d9ff8;
3454    pub const ON_DEVICE_GAIN_CHANGED: u64 = 0x14aefcbbb076b0e9;
3455    pub const ON_DEFAULT_DEVICE_CHANGED: u64 = 0x16357b42d4c16e11;
3456    pub const GET_DEVICE_GAIN: u64 = 0x25dd4723403c414b;
3457    pub const SET_DEVICE_GAIN: u64 = 0x5bdabc8ebe83591;
3458    pub const ADD_DEVICE_BY_CHANNEL: u64 = 0x72cdbada4d70ed67;
3459}
3460
3461pub mod audio_renderer_ordinals {
3462    pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3463    pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3464    pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3465    pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3466    pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3467    pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3468    pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3469    pub const BIND_GAIN_CONTROL: u64 = 0x293f5c7f8fba2bdc;
3470    pub const SET_PTS_UNITS: u64 = 0xf68cd108785a27c;
3471    pub const SET_PTS_CONTINUITY_THRESHOLD: u64 = 0x2849ba571d1971ba;
3472    pub const GET_REFERENCE_CLOCK: u64 = 0x2f7a7f011a172f7e;
3473    pub const SET_REFERENCE_CLOCK: u64 = 0x39acd05d832b5fed;
3474    pub const SET_USAGE: u64 = 0x3994bd23b55a733e;
3475    pub const SET_USAGE2: u64 = 0x2904035c7132b103;
3476    pub const SET_PCM_STREAM_TYPE: u64 = 0x27aa715d8901fa19;
3477    pub const ENABLE_MIN_LEAD_TIME_EVENTS: u64 = 0x62808dfad72bf890;
3478    pub const ON_MIN_LEAD_TIME_CHANGED: u64 = 0x4feff7d278978c4e;
3479    pub const GET_MIN_LEAD_TIME: u64 = 0x1cf3c3ecd8fec26b;
3480    pub const PLAY: u64 = 0x3c0162db084f74a3;
3481    pub const PLAY_NO_REPLY: u64 = 0x1b7fe832b68c22ef;
3482    pub const PAUSE: u64 = 0x41d557588d93d153;
3483    pub const PAUSE_NO_REPLY: u64 = 0x24cc45d4f3855ab;
3484}
3485
3486pub mod profile_provider_ordinals {
3487    pub const REGISTER_HANDLER_WITH_CAPACITY: u64 = 0x60459ecef7458176;
3488    pub const UNREGISTER_HANDLER: u64 = 0x724d9d5fd8ef544c;
3489    pub const REGISTER_MEMORY_RANGE: u64 = 0x2f509d3523e9562d;
3490    pub const UNREGISTER_MEMORY_RANGE: u64 = 0x2dc313d6aa81ad27;
3491}
3492
3493pub mod session_audio_consumer_factory_ordinals {
3494    pub const CREATE_AUDIO_CONSUMER: u64 = 0x6fab96f988e7d7fb;
3495}
3496
3497pub mod simple_stream_sink_ordinals {
3498    pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3499    pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3500    pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3501    pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3502    pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3503    pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3504    pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3505}
3506
3507pub mod stream_buffer_set_ordinals {
3508    pub const ADD_PAYLOAD_BUFFER: u64 = 0x3b3a37fc34fe5b56;
3509    pub const REMOVE_PAYLOAD_BUFFER: u64 = 0x5d1e4f74c3658262;
3510}
3511
3512pub mod stream_processor_ordinals {
3513    pub const ENABLE_ON_STREAM_FAILED: u64 = 0x3940929617dbf02b;
3514    pub const ON_STREAM_FAILED: u64 = 0x77ccf70bb061cf8e;
3515    pub const ON_INPUT_CONSTRAINTS: u64 = 0x211da9966a8ca0;
3516    pub const SET_INPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0xb02e0663a40e4c4;
3517    pub const ON_OUTPUT_CONSTRAINTS: u64 = 0x40d8234504c170f3;
3518    pub const ON_OUTPUT_FORMAT: u64 = 0x131b77ae120360bc;
3519    pub const SET_OUTPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0x118bb8c819a7bbbb;
3520    pub const COMPLETE_OUTPUT_BUFFER_PARTIAL_SETTINGS: u64 = 0x50529e5c680ae3ab;
3521    pub const FLUSH_END_OF_STREAM_AND_CLOSE_STREAM: u64 = 0x2b62c3e26d0667e6;
3522    pub const CLOSE_CURRENT_STREAM: u64 = 0x1d8a67522170ca07;
3523    pub const SYNC: u64 = 0x4b3e44300b0ec6aa;
3524    pub const ON_OUTPUT_PACKET: u64 = 0x5c2029be1090ce93;
3525    pub const RECYCLE_OUTPUT_PACKET: u64 = 0x32763632b94e0bd5;
3526    pub const ON_OUTPUT_END_OF_STREAM: u64 = 0x3bb65d237cfa50e6;
3527    pub const QUEUE_INPUT_FORMAT_DETAILS: u64 = 0x170dc0979d52231;
3528    pub const QUEUE_INPUT_PACKET: u64 = 0x47173d2652d9df3b;
3529    pub const ON_FREE_INPUT_PACKET: u64 = 0xeef799b28708bbd;
3530    pub const QUEUE_INPUT_END_OF_STREAM: u64 = 0x2051b6ad00f20b37;
3531}
3532
3533pub mod stream_sink_ordinals {
3534    pub const SEND_PACKET: u64 = 0x67cddd607442775f;
3535    pub const SEND_PACKET_NO_REPLY: u64 = 0x8d9b8b413ceba9d;
3536    pub const END_OF_STREAM: u64 = 0x6180fd6f7e793b71;
3537    pub const DISCARD_ALL_PACKETS: u64 = 0x6f4dad7af2917665;
3538    pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x50d36d0d23081bc4;
3539}
3540
3541pub mod stream_source_ordinals {
3542    pub const ON_PACKET_PRODUCED: u64 = 0x6bbe69746a3c8bd9;
3543    pub const ON_END_OF_STREAM: u64 = 0x550e69b41d03e2c2;
3544    pub const RELEASE_PACKET: u64 = 0x7a7b57f0f7d9e4bb;
3545    pub const DISCARD_ALL_PACKETS: u64 = 0x27afd605e97b09d2;
3546    pub const DISCARD_ALL_PACKETS_NO_REPLY: u64 = 0x35f9d721e905b831;
3547}
3548
3549pub mod usage2_audio_consumer_factory_ordinals {
3550    pub const CREATE_AUDIO_CONSUMER: u64 = 0x767722302a171873;
3551}
3552
3553pub mod usage_audio_consumer_factory_ordinals {
3554    pub const CREATE_AUDIO_CONSUMER: u64 = 0x4d975ca9b8f625a3;
3555}
3556
3557pub mod usage_gain_listener_ordinals {
3558    pub const ON_GAIN_MUTE_CHANGED: u64 = 0x681570258eac3a8d;
3559}
3560
3561pub mod usage_gain_reporter_ordinals {
3562    pub const REGISTER_LISTENER: u64 = 0x767107c168c226af;
3563    pub const REGISTER_LISTENER2: u64 = 0x760a8e1c5873629c;
3564}
3565
3566pub mod usage_reporter_ordinals {
3567    pub const WATCH: u64 = 0x769e6fb17075c959;
3568    pub const WATCH2: u64 = 0x4a43c4c82f5d8ce8;
3569}
3570
3571pub mod usage_watcher_ordinals {
3572    pub const ON_STATE_CHANGED: u64 = 0x5b955c5768ec75c5;
3573}
3574
3575pub mod usage_watcher2_ordinals {
3576    pub const ON_STATE_CHANGED: u64 = 0xca31a8b13c324d4;
3577}
3578
3579mod internal {
3580    use super::*;
3581    unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartFlags {
3582        type Owned = Self;
3583
3584        #[inline(always)]
3585        fn inline_align(_context: fidl::encoding::Context) -> usize {
3586            4
3587        }
3588
3589        #[inline(always)]
3590        fn inline_size(_context: fidl::encoding::Context) -> usize {
3591            4
3592        }
3593    }
3594
3595    impl fidl::encoding::ValueTypeMarker for AudioConsumerStartFlags {
3596        type Borrowed<'a> = Self;
3597        #[inline(always)]
3598        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3599            *value
3600        }
3601    }
3602
3603    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3604        for AudioConsumerStartFlags
3605    {
3606        #[inline]
3607        unsafe fn encode(
3608            self,
3609            encoder: &mut fidl::encoding::Encoder<'_, D>,
3610            offset: usize,
3611            _depth: fidl::encoding::Depth,
3612        ) -> fidl::Result<()> {
3613            encoder.debug_check_bounds::<Self>(offset);
3614            if self.bits() & Self::all().bits() != self.bits() {
3615                return Err(fidl::Error::InvalidBitsValue);
3616            }
3617            encoder.write_num(self.bits(), offset);
3618            Ok(())
3619        }
3620    }
3621
3622    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3623        for AudioConsumerStartFlags
3624    {
3625        #[inline(always)]
3626        fn new_empty() -> Self {
3627            Self::empty()
3628        }
3629
3630        #[inline]
3631        unsafe fn decode(
3632            &mut self,
3633            decoder: &mut fidl::encoding::Decoder<'_, D>,
3634            offset: usize,
3635            _depth: fidl::encoding::Depth,
3636        ) -> fidl::Result<()> {
3637            decoder.debug_check_bounds::<Self>(offset);
3638            let prim = decoder.read_num::<u32>(offset);
3639            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3640            Ok(())
3641        }
3642    }
3643    unsafe impl fidl::encoding::TypeMarker for AudioGainInfoFlags {
3644        type Owned = Self;
3645
3646        #[inline(always)]
3647        fn inline_align(_context: fidl::encoding::Context) -> usize {
3648            4
3649        }
3650
3651        #[inline(always)]
3652        fn inline_size(_context: fidl::encoding::Context) -> usize {
3653            4
3654        }
3655    }
3656
3657    impl fidl::encoding::ValueTypeMarker for AudioGainInfoFlags {
3658        type Borrowed<'a> = Self;
3659        #[inline(always)]
3660        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3661            *value
3662        }
3663    }
3664
3665    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3666        for AudioGainInfoFlags
3667    {
3668        #[inline]
3669        unsafe fn encode(
3670            self,
3671            encoder: &mut fidl::encoding::Encoder<'_, D>,
3672            offset: usize,
3673            _depth: fidl::encoding::Depth,
3674        ) -> fidl::Result<()> {
3675            encoder.debug_check_bounds::<Self>(offset);
3676            if self.bits() & Self::all().bits() != self.bits() {
3677                return Err(fidl::Error::InvalidBitsValue);
3678            }
3679            encoder.write_num(self.bits(), offset);
3680            Ok(())
3681        }
3682    }
3683
3684    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfoFlags {
3685        #[inline(always)]
3686        fn new_empty() -> Self {
3687            Self::empty()
3688        }
3689
3690        #[inline]
3691        unsafe fn decode(
3692            &mut self,
3693            decoder: &mut fidl::encoding::Decoder<'_, D>,
3694            offset: usize,
3695            _depth: fidl::encoding::Depth,
3696        ) -> fidl::Result<()> {
3697            decoder.debug_check_bounds::<Self>(offset);
3698            let prim = decoder.read_num::<u32>(offset);
3699            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3700            Ok(())
3701        }
3702    }
3703    unsafe impl fidl::encoding::TypeMarker for AudioGainValidFlags {
3704        type Owned = Self;
3705
3706        #[inline(always)]
3707        fn inline_align(_context: fidl::encoding::Context) -> usize {
3708            4
3709        }
3710
3711        #[inline(always)]
3712        fn inline_size(_context: fidl::encoding::Context) -> usize {
3713            4
3714        }
3715    }
3716
3717    impl fidl::encoding::ValueTypeMarker for AudioGainValidFlags {
3718        type Borrowed<'a> = Self;
3719        #[inline(always)]
3720        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3721            *value
3722        }
3723    }
3724
3725    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3726        for AudioGainValidFlags
3727    {
3728        #[inline]
3729        unsafe fn encode(
3730            self,
3731            encoder: &mut fidl::encoding::Encoder<'_, D>,
3732            offset: usize,
3733            _depth: fidl::encoding::Depth,
3734        ) -> fidl::Result<()> {
3735            encoder.debug_check_bounds::<Self>(offset);
3736            if self.bits() & Self::all().bits() != self.bits() {
3737                return Err(fidl::Error::InvalidBitsValue);
3738            }
3739            encoder.write_num(self.bits(), offset);
3740            Ok(())
3741        }
3742    }
3743
3744    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainValidFlags {
3745        #[inline(always)]
3746        fn new_empty() -> Self {
3747            Self::empty()
3748        }
3749
3750        #[inline]
3751        unsafe fn decode(
3752            &mut self,
3753            decoder: &mut fidl::encoding::Decoder<'_, D>,
3754            offset: usize,
3755            _depth: fidl::encoding::Depth,
3756        ) -> fidl::Result<()> {
3757            decoder.debug_check_bounds::<Self>(offset);
3758            let prim = decoder.read_num::<u32>(offset);
3759            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
3760            Ok(())
3761        }
3762    }
3763    unsafe impl fidl::encoding::TypeMarker for AacAudioObjectType {
3764        type Owned = Self;
3765
3766        #[inline(always)]
3767        fn inline_align(_context: fidl::encoding::Context) -> usize {
3768            std::mem::align_of::<u32>()
3769        }
3770
3771        #[inline(always)]
3772        fn inline_size(_context: fidl::encoding::Context) -> usize {
3773            std::mem::size_of::<u32>()
3774        }
3775
3776        #[inline(always)]
3777        fn encode_is_copy() -> bool {
3778            true
3779        }
3780
3781        #[inline(always)]
3782        fn decode_is_copy() -> bool {
3783            false
3784        }
3785    }
3786
3787    impl fidl::encoding::ValueTypeMarker for AacAudioObjectType {
3788        type Borrowed<'a> = Self;
3789        #[inline(always)]
3790        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3791            *value
3792        }
3793    }
3794
3795    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3796        for AacAudioObjectType
3797    {
3798        #[inline]
3799        unsafe fn encode(
3800            self,
3801            encoder: &mut fidl::encoding::Encoder<'_, D>,
3802            offset: usize,
3803            _depth: fidl::encoding::Depth,
3804        ) -> fidl::Result<()> {
3805            encoder.debug_check_bounds::<Self>(offset);
3806            encoder.write_num(self.into_primitive(), offset);
3807            Ok(())
3808        }
3809    }
3810
3811    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacAudioObjectType {
3812        #[inline(always)]
3813        fn new_empty() -> Self {
3814            Self::Mpeg2AacLc
3815        }
3816
3817        #[inline]
3818        unsafe fn decode(
3819            &mut self,
3820            decoder: &mut fidl::encoding::Decoder<'_, D>,
3821            offset: usize,
3822            _depth: fidl::encoding::Depth,
3823        ) -> fidl::Result<()> {
3824            decoder.debug_check_bounds::<Self>(offset);
3825            let prim = decoder.read_num::<u32>(offset);
3826
3827            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3828            Ok(())
3829        }
3830    }
3831    unsafe impl fidl::encoding::TypeMarker for AacChannelMode {
3832        type Owned = Self;
3833
3834        #[inline(always)]
3835        fn inline_align(_context: fidl::encoding::Context) -> usize {
3836            std::mem::align_of::<u32>()
3837        }
3838
3839        #[inline(always)]
3840        fn inline_size(_context: fidl::encoding::Context) -> usize {
3841            std::mem::size_of::<u32>()
3842        }
3843
3844        #[inline(always)]
3845        fn encode_is_copy() -> bool {
3846            true
3847        }
3848
3849        #[inline(always)]
3850        fn decode_is_copy() -> bool {
3851            false
3852        }
3853    }
3854
3855    impl fidl::encoding::ValueTypeMarker for AacChannelMode {
3856        type Borrowed<'a> = Self;
3857        #[inline(always)]
3858        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3859            *value
3860        }
3861    }
3862
3863    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AacChannelMode {
3864        #[inline]
3865        unsafe fn encode(
3866            self,
3867            encoder: &mut fidl::encoding::Encoder<'_, D>,
3868            offset: usize,
3869            _depth: fidl::encoding::Depth,
3870        ) -> fidl::Result<()> {
3871            encoder.debug_check_bounds::<Self>(offset);
3872            encoder.write_num(self.into_primitive(), offset);
3873            Ok(())
3874        }
3875    }
3876
3877    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacChannelMode {
3878        #[inline(always)]
3879        fn new_empty() -> Self {
3880            Self::Mono
3881        }
3882
3883        #[inline]
3884        unsafe fn decode(
3885            &mut self,
3886            decoder: &mut fidl::encoding::Decoder<'_, D>,
3887            offset: usize,
3888            _depth: fidl::encoding::Depth,
3889        ) -> fidl::Result<()> {
3890            decoder.debug_check_bounds::<Self>(offset);
3891            let prim = decoder.read_num::<u32>(offset);
3892
3893            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3894            Ok(())
3895        }
3896    }
3897    unsafe impl fidl::encoding::TypeMarker for AacVariableBitRate {
3898        type Owned = Self;
3899
3900        #[inline(always)]
3901        fn inline_align(_context: fidl::encoding::Context) -> usize {
3902            std::mem::align_of::<u32>()
3903        }
3904
3905        #[inline(always)]
3906        fn inline_size(_context: fidl::encoding::Context) -> usize {
3907            std::mem::size_of::<u32>()
3908        }
3909
3910        #[inline(always)]
3911        fn encode_is_copy() -> bool {
3912            true
3913        }
3914
3915        #[inline(always)]
3916        fn decode_is_copy() -> bool {
3917            false
3918        }
3919    }
3920
3921    impl fidl::encoding::ValueTypeMarker for AacVariableBitRate {
3922        type Borrowed<'a> = Self;
3923        #[inline(always)]
3924        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3925            *value
3926        }
3927    }
3928
3929    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3930        for AacVariableBitRate
3931    {
3932        #[inline]
3933        unsafe fn encode(
3934            self,
3935            encoder: &mut fidl::encoding::Encoder<'_, D>,
3936            offset: usize,
3937            _depth: fidl::encoding::Depth,
3938        ) -> fidl::Result<()> {
3939            encoder.debug_check_bounds::<Self>(offset);
3940            encoder.write_num(self.into_primitive(), offset);
3941            Ok(())
3942        }
3943    }
3944
3945    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacVariableBitRate {
3946        #[inline(always)]
3947        fn new_empty() -> Self {
3948            Self::V1
3949        }
3950
3951        #[inline]
3952        unsafe fn decode(
3953            &mut self,
3954            decoder: &mut fidl::encoding::Decoder<'_, D>,
3955            offset: usize,
3956            _depth: fidl::encoding::Depth,
3957        ) -> fidl::Result<()> {
3958            decoder.debug_check_bounds::<Self>(offset);
3959            let prim = decoder.read_num::<u32>(offset);
3960
3961            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3962            Ok(())
3963        }
3964    }
3965    unsafe impl fidl::encoding::TypeMarker for AudioBitrateMode {
3966        type Owned = Self;
3967
3968        #[inline(always)]
3969        fn inline_align(_context: fidl::encoding::Context) -> usize {
3970            std::mem::align_of::<u32>()
3971        }
3972
3973        #[inline(always)]
3974        fn inline_size(_context: fidl::encoding::Context) -> usize {
3975            std::mem::size_of::<u32>()
3976        }
3977
3978        #[inline(always)]
3979        fn encode_is_copy() -> bool {
3980            true
3981        }
3982
3983        #[inline(always)]
3984        fn decode_is_copy() -> bool {
3985            false
3986        }
3987    }
3988
3989    impl fidl::encoding::ValueTypeMarker for AudioBitrateMode {
3990        type Borrowed<'a> = Self;
3991        #[inline(always)]
3992        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3993            *value
3994        }
3995    }
3996
3997    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3998        for AudioBitrateMode
3999    {
4000        #[inline]
4001        unsafe fn encode(
4002            self,
4003            encoder: &mut fidl::encoding::Encoder<'_, D>,
4004            offset: usize,
4005            _depth: fidl::encoding::Depth,
4006        ) -> fidl::Result<()> {
4007            encoder.debug_check_bounds::<Self>(offset);
4008            encoder.write_num(self.into_primitive(), offset);
4009            Ok(())
4010        }
4011    }
4012
4013    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioBitrateMode {
4014        #[inline(always)]
4015        fn new_empty() -> Self {
4016            Self::Unspecified
4017        }
4018
4019        #[inline]
4020        unsafe fn decode(
4021            &mut self,
4022            decoder: &mut fidl::encoding::Decoder<'_, D>,
4023            offset: usize,
4024            _depth: fidl::encoding::Depth,
4025        ) -> fidl::Result<()> {
4026            decoder.debug_check_bounds::<Self>(offset);
4027            let prim = decoder.read_num::<u32>(offset);
4028
4029            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4030            Ok(())
4031        }
4032    }
4033    unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage {
4034        type Owned = Self;
4035
4036        #[inline(always)]
4037        fn inline_align(_context: fidl::encoding::Context) -> usize {
4038            std::mem::align_of::<u32>()
4039        }
4040
4041        #[inline(always)]
4042        fn inline_size(_context: fidl::encoding::Context) -> usize {
4043            std::mem::size_of::<u32>()
4044        }
4045
4046        #[inline(always)]
4047        fn encode_is_copy() -> bool {
4048            true
4049        }
4050
4051        #[inline(always)]
4052        fn decode_is_copy() -> bool {
4053            false
4054        }
4055    }
4056
4057    impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage {
4058        type Borrowed<'a> = Self;
4059        #[inline(always)]
4060        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4061            *value
4062        }
4063    }
4064
4065    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4066        for AudioCaptureUsage
4067    {
4068        #[inline]
4069        unsafe fn encode(
4070            self,
4071            encoder: &mut fidl::encoding::Encoder<'_, D>,
4072            offset: usize,
4073            _depth: fidl::encoding::Depth,
4074        ) -> fidl::Result<()> {
4075            encoder.debug_check_bounds::<Self>(offset);
4076            encoder.write_num(self.into_primitive(), offset);
4077            Ok(())
4078        }
4079    }
4080
4081    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage {
4082        #[inline(always)]
4083        fn new_empty() -> Self {
4084            Self::Background
4085        }
4086
4087        #[inline]
4088        unsafe fn decode(
4089            &mut self,
4090            decoder: &mut fidl::encoding::Decoder<'_, D>,
4091            offset: usize,
4092            _depth: fidl::encoding::Depth,
4093        ) -> fidl::Result<()> {
4094            decoder.debug_check_bounds::<Self>(offset);
4095            let prim = decoder.read_num::<u32>(offset);
4096
4097            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4098            Ok(())
4099        }
4100    }
4101    unsafe impl fidl::encoding::TypeMarker for AudioCaptureUsage2 {
4102        type Owned = Self;
4103
4104        #[inline(always)]
4105        fn inline_align(_context: fidl::encoding::Context) -> usize {
4106            std::mem::align_of::<u32>()
4107        }
4108
4109        #[inline(always)]
4110        fn inline_size(_context: fidl::encoding::Context) -> usize {
4111            std::mem::size_of::<u32>()
4112        }
4113
4114        #[inline(always)]
4115        fn encode_is_copy() -> bool {
4116            false
4117        }
4118
4119        #[inline(always)]
4120        fn decode_is_copy() -> bool {
4121            false
4122        }
4123    }
4124
4125    impl fidl::encoding::ValueTypeMarker for AudioCaptureUsage2 {
4126        type Borrowed<'a> = Self;
4127        #[inline(always)]
4128        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4129            *value
4130        }
4131    }
4132
4133    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4134        for AudioCaptureUsage2
4135    {
4136        #[inline]
4137        unsafe fn encode(
4138            self,
4139            encoder: &mut fidl::encoding::Encoder<'_, D>,
4140            offset: usize,
4141            _depth: fidl::encoding::Depth,
4142        ) -> fidl::Result<()> {
4143            encoder.debug_check_bounds::<Self>(offset);
4144            encoder.write_num(self.into_primitive(), offset);
4145            Ok(())
4146        }
4147    }
4148
4149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCaptureUsage2 {
4150        #[inline(always)]
4151        fn new_empty() -> Self {
4152            Self::unknown()
4153        }
4154
4155        #[inline]
4156        unsafe fn decode(
4157            &mut self,
4158            decoder: &mut fidl::encoding::Decoder<'_, D>,
4159            offset: usize,
4160            _depth: fidl::encoding::Depth,
4161        ) -> fidl::Result<()> {
4162            decoder.debug_check_bounds::<Self>(offset);
4163            let prim = decoder.read_num::<u32>(offset);
4164
4165            *self = Self::from_primitive_allow_unknown(prim);
4166            Ok(())
4167        }
4168    }
4169    unsafe impl fidl::encoding::TypeMarker for AudioChannelId {
4170        type Owned = Self;
4171
4172        #[inline(always)]
4173        fn inline_align(_context: fidl::encoding::Context) -> usize {
4174            std::mem::align_of::<u32>()
4175        }
4176
4177        #[inline(always)]
4178        fn inline_size(_context: fidl::encoding::Context) -> usize {
4179            std::mem::size_of::<u32>()
4180        }
4181
4182        #[inline(always)]
4183        fn encode_is_copy() -> bool {
4184            true
4185        }
4186
4187        #[inline(always)]
4188        fn decode_is_copy() -> bool {
4189            false
4190        }
4191    }
4192
4193    impl fidl::encoding::ValueTypeMarker for AudioChannelId {
4194        type Borrowed<'a> = Self;
4195        #[inline(always)]
4196        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4197            *value
4198        }
4199    }
4200
4201    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioChannelId {
4202        #[inline]
4203        unsafe fn encode(
4204            self,
4205            encoder: &mut fidl::encoding::Encoder<'_, D>,
4206            offset: usize,
4207            _depth: fidl::encoding::Depth,
4208        ) -> fidl::Result<()> {
4209            encoder.debug_check_bounds::<Self>(offset);
4210            encoder.write_num(self.into_primitive(), offset);
4211            Ok(())
4212        }
4213    }
4214
4215    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioChannelId {
4216        #[inline(always)]
4217        fn new_empty() -> Self {
4218            Self::Skip
4219        }
4220
4221        #[inline]
4222        unsafe fn decode(
4223            &mut self,
4224            decoder: &mut fidl::encoding::Decoder<'_, D>,
4225            offset: usize,
4226            _depth: fidl::encoding::Depth,
4227        ) -> fidl::Result<()> {
4228            decoder.debug_check_bounds::<Self>(offset);
4229            let prim = decoder.read_num::<u32>(offset);
4230
4231            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4232            Ok(())
4233        }
4234    }
4235    unsafe impl fidl::encoding::TypeMarker for AudioOutputRoutingPolicy {
4236        type Owned = Self;
4237
4238        #[inline(always)]
4239        fn inline_align(_context: fidl::encoding::Context) -> usize {
4240            std::mem::align_of::<u32>()
4241        }
4242
4243        #[inline(always)]
4244        fn inline_size(_context: fidl::encoding::Context) -> usize {
4245            std::mem::size_of::<u32>()
4246        }
4247
4248        #[inline(always)]
4249        fn encode_is_copy() -> bool {
4250            true
4251        }
4252
4253        #[inline(always)]
4254        fn decode_is_copy() -> bool {
4255            false
4256        }
4257    }
4258
4259    impl fidl::encoding::ValueTypeMarker for AudioOutputRoutingPolicy {
4260        type Borrowed<'a> = Self;
4261        #[inline(always)]
4262        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4263            *value
4264        }
4265    }
4266
4267    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4268        for AudioOutputRoutingPolicy
4269    {
4270        #[inline]
4271        unsafe fn encode(
4272            self,
4273            encoder: &mut fidl::encoding::Encoder<'_, D>,
4274            offset: usize,
4275            _depth: fidl::encoding::Depth,
4276        ) -> fidl::Result<()> {
4277            encoder.debug_check_bounds::<Self>(offset);
4278            encoder.write_num(self.into_primitive(), offset);
4279            Ok(())
4280        }
4281    }
4282
4283    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4284        for AudioOutputRoutingPolicy
4285    {
4286        #[inline(always)]
4287        fn new_empty() -> Self {
4288            Self::AllPluggedOutputs
4289        }
4290
4291        #[inline]
4292        unsafe fn decode(
4293            &mut self,
4294            decoder: &mut fidl::encoding::Decoder<'_, D>,
4295            offset: usize,
4296            _depth: fidl::encoding::Depth,
4297        ) -> fidl::Result<()> {
4298            decoder.debug_check_bounds::<Self>(offset);
4299            let prim = decoder.read_num::<u32>(offset);
4300
4301            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4302            Ok(())
4303        }
4304    }
4305    unsafe impl fidl::encoding::TypeMarker for AudioPcmMode {
4306        type Owned = Self;
4307
4308        #[inline(always)]
4309        fn inline_align(_context: fidl::encoding::Context) -> usize {
4310            std::mem::align_of::<u32>()
4311        }
4312
4313        #[inline(always)]
4314        fn inline_size(_context: fidl::encoding::Context) -> usize {
4315            std::mem::size_of::<u32>()
4316        }
4317
4318        #[inline(always)]
4319        fn encode_is_copy() -> bool {
4320            true
4321        }
4322
4323        #[inline(always)]
4324        fn decode_is_copy() -> bool {
4325            false
4326        }
4327    }
4328
4329    impl fidl::encoding::ValueTypeMarker for AudioPcmMode {
4330        type Borrowed<'a> = Self;
4331        #[inline(always)]
4332        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4333            *value
4334        }
4335    }
4336
4337    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AudioPcmMode {
4338        #[inline]
4339        unsafe fn encode(
4340            self,
4341            encoder: &mut fidl::encoding::Encoder<'_, D>,
4342            offset: usize,
4343            _depth: fidl::encoding::Depth,
4344        ) -> fidl::Result<()> {
4345            encoder.debug_check_bounds::<Self>(offset);
4346            encoder.write_num(self.into_primitive(), offset);
4347            Ok(())
4348        }
4349    }
4350
4351    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioPcmMode {
4352        #[inline(always)]
4353        fn new_empty() -> Self {
4354            Self::Linear
4355        }
4356
4357        #[inline]
4358        unsafe fn decode(
4359            &mut self,
4360            decoder: &mut fidl::encoding::Decoder<'_, D>,
4361            offset: usize,
4362            _depth: fidl::encoding::Depth,
4363        ) -> fidl::Result<()> {
4364            decoder.debug_check_bounds::<Self>(offset);
4365            let prim = decoder.read_num::<u32>(offset);
4366
4367            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4368            Ok(())
4369        }
4370    }
4371    unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage {
4372        type Owned = Self;
4373
4374        #[inline(always)]
4375        fn inline_align(_context: fidl::encoding::Context) -> usize {
4376            std::mem::align_of::<u32>()
4377        }
4378
4379        #[inline(always)]
4380        fn inline_size(_context: fidl::encoding::Context) -> usize {
4381            std::mem::size_of::<u32>()
4382        }
4383
4384        #[inline(always)]
4385        fn encode_is_copy() -> bool {
4386            true
4387        }
4388
4389        #[inline(always)]
4390        fn decode_is_copy() -> bool {
4391            false
4392        }
4393    }
4394
4395    impl fidl::encoding::ValueTypeMarker for AudioRenderUsage {
4396        type Borrowed<'a> = Self;
4397        #[inline(always)]
4398        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4399            *value
4400        }
4401    }
4402
4403    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4404        for AudioRenderUsage
4405    {
4406        #[inline]
4407        unsafe fn encode(
4408            self,
4409            encoder: &mut fidl::encoding::Encoder<'_, D>,
4410            offset: usize,
4411            _depth: fidl::encoding::Depth,
4412        ) -> fidl::Result<()> {
4413            encoder.debug_check_bounds::<Self>(offset);
4414            encoder.write_num(self.into_primitive(), offset);
4415            Ok(())
4416        }
4417    }
4418
4419    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage {
4420        #[inline(always)]
4421        fn new_empty() -> Self {
4422            Self::Background
4423        }
4424
4425        #[inline]
4426        unsafe fn decode(
4427            &mut self,
4428            decoder: &mut fidl::encoding::Decoder<'_, D>,
4429            offset: usize,
4430            _depth: fidl::encoding::Depth,
4431        ) -> fidl::Result<()> {
4432            decoder.debug_check_bounds::<Self>(offset);
4433            let prim = decoder.read_num::<u32>(offset);
4434
4435            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4436            Ok(())
4437        }
4438    }
4439    unsafe impl fidl::encoding::TypeMarker for AudioRenderUsage2 {
4440        type Owned = Self;
4441
4442        #[inline(always)]
4443        fn inline_align(_context: fidl::encoding::Context) -> usize {
4444            std::mem::align_of::<u32>()
4445        }
4446
4447        #[inline(always)]
4448        fn inline_size(_context: fidl::encoding::Context) -> usize {
4449            std::mem::size_of::<u32>()
4450        }
4451
4452        #[inline(always)]
4453        fn encode_is_copy() -> bool {
4454            false
4455        }
4456
4457        #[inline(always)]
4458        fn decode_is_copy() -> bool {
4459            false
4460        }
4461    }
4462
4463    impl fidl::encoding::ValueTypeMarker for AudioRenderUsage2 {
4464        type Borrowed<'a> = Self;
4465        #[inline(always)]
4466        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4467            *value
4468        }
4469    }
4470
4471    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4472        for AudioRenderUsage2
4473    {
4474        #[inline]
4475        unsafe fn encode(
4476            self,
4477            encoder: &mut fidl::encoding::Encoder<'_, D>,
4478            offset: usize,
4479            _depth: fidl::encoding::Depth,
4480        ) -> fidl::Result<()> {
4481            encoder.debug_check_bounds::<Self>(offset);
4482            encoder.write_num(self.into_primitive(), offset);
4483            Ok(())
4484        }
4485    }
4486
4487    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioRenderUsage2 {
4488        #[inline(always)]
4489        fn new_empty() -> Self {
4490            Self::unknown()
4491        }
4492
4493        #[inline]
4494        unsafe fn decode(
4495            &mut self,
4496            decoder: &mut fidl::encoding::Decoder<'_, D>,
4497            offset: usize,
4498            _depth: fidl::encoding::Depth,
4499        ) -> fidl::Result<()> {
4500            decoder.debug_check_bounds::<Self>(offset);
4501            let prim = decoder.read_num::<u32>(offset);
4502
4503            *self = Self::from_primitive_allow_unknown(prim);
4504            Ok(())
4505        }
4506    }
4507    unsafe impl fidl::encoding::TypeMarker for AudioSampleFormat {
4508        type Owned = Self;
4509
4510        #[inline(always)]
4511        fn inline_align(_context: fidl::encoding::Context) -> usize {
4512            std::mem::align_of::<u32>()
4513        }
4514
4515        #[inline(always)]
4516        fn inline_size(_context: fidl::encoding::Context) -> usize {
4517            std::mem::size_of::<u32>()
4518        }
4519
4520        #[inline(always)]
4521        fn encode_is_copy() -> bool {
4522            true
4523        }
4524
4525        #[inline(always)]
4526        fn decode_is_copy() -> bool {
4527            false
4528        }
4529    }
4530
4531    impl fidl::encoding::ValueTypeMarker for AudioSampleFormat {
4532        type Borrowed<'a> = Self;
4533        #[inline(always)]
4534        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4535            *value
4536        }
4537    }
4538
4539    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4540        for AudioSampleFormat
4541    {
4542        #[inline]
4543        unsafe fn encode(
4544            self,
4545            encoder: &mut fidl::encoding::Encoder<'_, D>,
4546            offset: usize,
4547            _depth: fidl::encoding::Depth,
4548        ) -> fidl::Result<()> {
4549            encoder.debug_check_bounds::<Self>(offset);
4550            encoder.write_num(self.into_primitive(), offset);
4551            Ok(())
4552        }
4553    }
4554
4555    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioSampleFormat {
4556        #[inline(always)]
4557        fn new_empty() -> Self {
4558            Self::Unsigned8
4559        }
4560
4561        #[inline]
4562        unsafe fn decode(
4563            &mut self,
4564            decoder: &mut fidl::encoding::Decoder<'_, D>,
4565            offset: usize,
4566            _depth: fidl::encoding::Depth,
4567        ) -> fidl::Result<()> {
4568            decoder.debug_check_bounds::<Self>(offset);
4569            let prim = decoder.read_num::<u32>(offset);
4570
4571            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4572            Ok(())
4573        }
4574    }
4575    unsafe impl fidl::encoding::TypeMarker for Behavior {
4576        type Owned = Self;
4577
4578        #[inline(always)]
4579        fn inline_align(_context: fidl::encoding::Context) -> usize {
4580            std::mem::align_of::<u32>()
4581        }
4582
4583        #[inline(always)]
4584        fn inline_size(_context: fidl::encoding::Context) -> usize {
4585            std::mem::size_of::<u32>()
4586        }
4587
4588        #[inline(always)]
4589        fn encode_is_copy() -> bool {
4590            false
4591        }
4592
4593        #[inline(always)]
4594        fn decode_is_copy() -> bool {
4595            false
4596        }
4597    }
4598
4599    impl fidl::encoding::ValueTypeMarker for Behavior {
4600        type Borrowed<'a> = Self;
4601        #[inline(always)]
4602        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4603            *value
4604        }
4605    }
4606
4607    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Behavior {
4608        #[inline]
4609        unsafe fn encode(
4610            self,
4611            encoder: &mut fidl::encoding::Encoder<'_, D>,
4612            offset: usize,
4613            _depth: fidl::encoding::Depth,
4614        ) -> fidl::Result<()> {
4615            encoder.debug_check_bounds::<Self>(offset);
4616            encoder.write_num(self.into_primitive(), offset);
4617            Ok(())
4618        }
4619    }
4620
4621    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Behavior {
4622        #[inline(always)]
4623        fn new_empty() -> Self {
4624            Self::unknown()
4625        }
4626
4627        #[inline]
4628        unsafe fn decode(
4629            &mut self,
4630            decoder: &mut fidl::encoding::Decoder<'_, D>,
4631            offset: usize,
4632            _depth: fidl::encoding::Depth,
4633        ) -> fidl::Result<()> {
4634            decoder.debug_check_bounds::<Self>(offset);
4635            let prim = decoder.read_num::<u32>(offset);
4636
4637            *self = Self::from_primitive_allow_unknown(prim);
4638            Ok(())
4639        }
4640    }
4641    unsafe impl fidl::encoding::TypeMarker for CodecProfile {
4642        type Owned = Self;
4643
4644        #[inline(always)]
4645        fn inline_align(_context: fidl::encoding::Context) -> usize {
4646            std::mem::align_of::<u32>()
4647        }
4648
4649        #[inline(always)]
4650        fn inline_size(_context: fidl::encoding::Context) -> usize {
4651            std::mem::size_of::<u32>()
4652        }
4653
4654        #[inline(always)]
4655        fn encode_is_copy() -> bool {
4656            false
4657        }
4658
4659        #[inline(always)]
4660        fn decode_is_copy() -> bool {
4661            false
4662        }
4663    }
4664
4665    impl fidl::encoding::ValueTypeMarker for CodecProfile {
4666        type Borrowed<'a> = Self;
4667        #[inline(always)]
4668        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4669            *value
4670        }
4671    }
4672
4673    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CodecProfile {
4674        #[inline]
4675        unsafe fn encode(
4676            self,
4677            encoder: &mut fidl::encoding::Encoder<'_, D>,
4678            offset: usize,
4679            _depth: fidl::encoding::Depth,
4680        ) -> fidl::Result<()> {
4681            encoder.debug_check_bounds::<Self>(offset);
4682            encoder.write_num(self.into_primitive(), offset);
4683            Ok(())
4684        }
4685    }
4686
4687    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CodecProfile {
4688        #[inline(always)]
4689        fn new_empty() -> Self {
4690            Self::unknown()
4691        }
4692
4693        #[inline]
4694        unsafe fn decode(
4695            &mut self,
4696            decoder: &mut fidl::encoding::Decoder<'_, D>,
4697            offset: usize,
4698            _depth: fidl::encoding::Depth,
4699        ) -> fidl::Result<()> {
4700            decoder.debug_check_bounds::<Self>(offset);
4701            let prim = decoder.read_num::<u32>(offset);
4702
4703            *self = Self::from_primitive_allow_unknown(prim);
4704            Ok(())
4705        }
4706    }
4707    unsafe impl fidl::encoding::TypeMarker for ColorSpace {
4708        type Owned = Self;
4709
4710        #[inline(always)]
4711        fn inline_align(_context: fidl::encoding::Context) -> usize {
4712            std::mem::align_of::<u32>()
4713        }
4714
4715        #[inline(always)]
4716        fn inline_size(_context: fidl::encoding::Context) -> usize {
4717            std::mem::size_of::<u32>()
4718        }
4719
4720        #[inline(always)]
4721        fn encode_is_copy() -> bool {
4722            true
4723        }
4724
4725        #[inline(always)]
4726        fn decode_is_copy() -> bool {
4727            false
4728        }
4729    }
4730
4731    impl fidl::encoding::ValueTypeMarker for ColorSpace {
4732        type Borrowed<'a> = Self;
4733        #[inline(always)]
4734        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4735            *value
4736        }
4737    }
4738
4739    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ColorSpace {
4740        #[inline]
4741        unsafe fn encode(
4742            self,
4743            encoder: &mut fidl::encoding::Encoder<'_, D>,
4744            offset: usize,
4745            _depth: fidl::encoding::Depth,
4746        ) -> fidl::Result<()> {
4747            encoder.debug_check_bounds::<Self>(offset);
4748            encoder.write_num(self.into_primitive(), offset);
4749            Ok(())
4750        }
4751    }
4752
4753    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorSpace {
4754        #[inline(always)]
4755        fn new_empty() -> Self {
4756            Self::Unknown
4757        }
4758
4759        #[inline]
4760        unsafe fn decode(
4761            &mut self,
4762            decoder: &mut fidl::encoding::Decoder<'_, D>,
4763            offset: usize,
4764            _depth: fidl::encoding::Depth,
4765        ) -> fidl::Result<()> {
4766            decoder.debug_check_bounds::<Self>(offset);
4767            let prim = decoder.read_num::<u32>(offset);
4768
4769            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4770            Ok(())
4771        }
4772    }
4773    unsafe impl fidl::encoding::TypeMarker for Lc3FrameDuration {
4774        type Owned = Self;
4775
4776        #[inline(always)]
4777        fn inline_align(_context: fidl::encoding::Context) -> usize {
4778            std::mem::align_of::<u32>()
4779        }
4780
4781        #[inline(always)]
4782        fn inline_size(_context: fidl::encoding::Context) -> usize {
4783            std::mem::size_of::<u32>()
4784        }
4785
4786        #[inline(always)]
4787        fn encode_is_copy() -> bool {
4788            false
4789        }
4790
4791        #[inline(always)]
4792        fn decode_is_copy() -> bool {
4793            false
4794        }
4795    }
4796
4797    impl fidl::encoding::ValueTypeMarker for Lc3FrameDuration {
4798        type Borrowed<'a> = Self;
4799        #[inline(always)]
4800        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4801            *value
4802        }
4803    }
4804
4805    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
4806        for Lc3FrameDuration
4807    {
4808        #[inline]
4809        unsafe fn encode(
4810            self,
4811            encoder: &mut fidl::encoding::Encoder<'_, D>,
4812            offset: usize,
4813            _depth: fidl::encoding::Depth,
4814        ) -> fidl::Result<()> {
4815            encoder.debug_check_bounds::<Self>(offset);
4816            encoder.write_num(self.into_primitive(), offset);
4817            Ok(())
4818        }
4819    }
4820
4821    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3FrameDuration {
4822        #[inline(always)]
4823        fn new_empty() -> Self {
4824            Self::unknown()
4825        }
4826
4827        #[inline]
4828        unsafe fn decode(
4829            &mut self,
4830            decoder: &mut fidl::encoding::Decoder<'_, D>,
4831            offset: usize,
4832            _depth: fidl::encoding::Depth,
4833        ) -> fidl::Result<()> {
4834            decoder.debug_check_bounds::<Self>(offset);
4835            let prim = decoder.read_num::<u32>(offset);
4836
4837            *self = Self::from_primitive_allow_unknown(prim);
4838            Ok(())
4839        }
4840    }
4841    unsafe impl fidl::encoding::TypeMarker for SbcAllocation {
4842        type Owned = Self;
4843
4844        #[inline(always)]
4845        fn inline_align(_context: fidl::encoding::Context) -> usize {
4846            std::mem::align_of::<u32>()
4847        }
4848
4849        #[inline(always)]
4850        fn inline_size(_context: fidl::encoding::Context) -> usize {
4851            std::mem::size_of::<u32>()
4852        }
4853
4854        #[inline(always)]
4855        fn encode_is_copy() -> bool {
4856            true
4857        }
4858
4859        #[inline(always)]
4860        fn decode_is_copy() -> bool {
4861            false
4862        }
4863    }
4864
4865    impl fidl::encoding::ValueTypeMarker for SbcAllocation {
4866        type Borrowed<'a> = Self;
4867        #[inline(always)]
4868        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4869            *value
4870        }
4871    }
4872
4873    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcAllocation {
4874        #[inline]
4875        unsafe fn encode(
4876            self,
4877            encoder: &mut fidl::encoding::Encoder<'_, D>,
4878            offset: usize,
4879            _depth: fidl::encoding::Depth,
4880        ) -> fidl::Result<()> {
4881            encoder.debug_check_bounds::<Self>(offset);
4882            encoder.write_num(self.into_primitive(), offset);
4883            Ok(())
4884        }
4885    }
4886
4887    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcAllocation {
4888        #[inline(always)]
4889        fn new_empty() -> Self {
4890            Self::AllocLoudness
4891        }
4892
4893        #[inline]
4894        unsafe fn decode(
4895            &mut self,
4896            decoder: &mut fidl::encoding::Decoder<'_, D>,
4897            offset: usize,
4898            _depth: fidl::encoding::Depth,
4899        ) -> fidl::Result<()> {
4900            decoder.debug_check_bounds::<Self>(offset);
4901            let prim = decoder.read_num::<u32>(offset);
4902
4903            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4904            Ok(())
4905        }
4906    }
4907    unsafe impl fidl::encoding::TypeMarker for SbcBlockCount {
4908        type Owned = Self;
4909
4910        #[inline(always)]
4911        fn inline_align(_context: fidl::encoding::Context) -> usize {
4912            std::mem::align_of::<u32>()
4913        }
4914
4915        #[inline(always)]
4916        fn inline_size(_context: fidl::encoding::Context) -> usize {
4917            std::mem::size_of::<u32>()
4918        }
4919
4920        #[inline(always)]
4921        fn encode_is_copy() -> bool {
4922            true
4923        }
4924
4925        #[inline(always)]
4926        fn decode_is_copy() -> bool {
4927            false
4928        }
4929    }
4930
4931    impl fidl::encoding::ValueTypeMarker for SbcBlockCount {
4932        type Borrowed<'a> = Self;
4933        #[inline(always)]
4934        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4935            *value
4936        }
4937    }
4938
4939    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcBlockCount {
4940        #[inline]
4941        unsafe fn encode(
4942            self,
4943            encoder: &mut fidl::encoding::Encoder<'_, D>,
4944            offset: usize,
4945            _depth: fidl::encoding::Depth,
4946        ) -> fidl::Result<()> {
4947            encoder.debug_check_bounds::<Self>(offset);
4948            encoder.write_num(self.into_primitive(), offset);
4949            Ok(())
4950        }
4951    }
4952
4953    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcBlockCount {
4954        #[inline(always)]
4955        fn new_empty() -> Self {
4956            Self::BlockCount4
4957        }
4958
4959        #[inline]
4960        unsafe fn decode(
4961            &mut self,
4962            decoder: &mut fidl::encoding::Decoder<'_, D>,
4963            offset: usize,
4964            _depth: fidl::encoding::Depth,
4965        ) -> fidl::Result<()> {
4966            decoder.debug_check_bounds::<Self>(offset);
4967            let prim = decoder.read_num::<u32>(offset);
4968
4969            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
4970            Ok(())
4971        }
4972    }
4973    unsafe impl fidl::encoding::TypeMarker for SbcChannelMode {
4974        type Owned = Self;
4975
4976        #[inline(always)]
4977        fn inline_align(_context: fidl::encoding::Context) -> usize {
4978            std::mem::align_of::<u32>()
4979        }
4980
4981        #[inline(always)]
4982        fn inline_size(_context: fidl::encoding::Context) -> usize {
4983            std::mem::size_of::<u32>()
4984        }
4985
4986        #[inline(always)]
4987        fn encode_is_copy() -> bool {
4988            true
4989        }
4990
4991        #[inline(always)]
4992        fn decode_is_copy() -> bool {
4993            false
4994        }
4995    }
4996
4997    impl fidl::encoding::ValueTypeMarker for SbcChannelMode {
4998        type Borrowed<'a> = Self;
4999        #[inline(always)]
5000        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5001            *value
5002        }
5003    }
5004
5005    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcChannelMode {
5006        #[inline]
5007        unsafe fn encode(
5008            self,
5009            encoder: &mut fidl::encoding::Encoder<'_, D>,
5010            offset: usize,
5011            _depth: fidl::encoding::Depth,
5012        ) -> fidl::Result<()> {
5013            encoder.debug_check_bounds::<Self>(offset);
5014            encoder.write_num(self.into_primitive(), offset);
5015            Ok(())
5016        }
5017    }
5018
5019    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcChannelMode {
5020        #[inline(always)]
5021        fn new_empty() -> Self {
5022            Self::Mono
5023        }
5024
5025        #[inline]
5026        unsafe fn decode(
5027            &mut self,
5028            decoder: &mut fidl::encoding::Decoder<'_, D>,
5029            offset: usize,
5030            _depth: fidl::encoding::Depth,
5031        ) -> fidl::Result<()> {
5032            decoder.debug_check_bounds::<Self>(offset);
5033            let prim = decoder.read_num::<u32>(offset);
5034
5035            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5036            Ok(())
5037        }
5038    }
5039    unsafe impl fidl::encoding::TypeMarker for SbcSubBands {
5040        type Owned = Self;
5041
5042        #[inline(always)]
5043        fn inline_align(_context: fidl::encoding::Context) -> usize {
5044            std::mem::align_of::<u32>()
5045        }
5046
5047        #[inline(always)]
5048        fn inline_size(_context: fidl::encoding::Context) -> usize {
5049            std::mem::size_of::<u32>()
5050        }
5051
5052        #[inline(always)]
5053        fn encode_is_copy() -> bool {
5054            true
5055        }
5056
5057        #[inline(always)]
5058        fn decode_is_copy() -> bool {
5059            false
5060        }
5061    }
5062
5063    impl fidl::encoding::ValueTypeMarker for SbcSubBands {
5064        type Borrowed<'a> = Self;
5065        #[inline(always)]
5066        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5067            *value
5068        }
5069    }
5070
5071    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SbcSubBands {
5072        #[inline]
5073        unsafe fn encode(
5074            self,
5075            encoder: &mut fidl::encoding::Encoder<'_, D>,
5076            offset: usize,
5077            _depth: fidl::encoding::Depth,
5078        ) -> fidl::Result<()> {
5079            encoder.debug_check_bounds::<Self>(offset);
5080            encoder.write_num(self.into_primitive(), offset);
5081            Ok(())
5082        }
5083    }
5084
5085    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcSubBands {
5086        #[inline(always)]
5087        fn new_empty() -> Self {
5088            Self::SubBands4
5089        }
5090
5091        #[inline]
5092        unsafe fn decode(
5093            &mut self,
5094            decoder: &mut fidl::encoding::Decoder<'_, D>,
5095            offset: usize,
5096            _depth: fidl::encoding::Depth,
5097        ) -> fidl::Result<()> {
5098            decoder.debug_check_bounds::<Self>(offset);
5099            let prim = decoder.read_num::<u32>(offset);
5100
5101            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5102            Ok(())
5103        }
5104    }
5105    unsafe impl fidl::encoding::TypeMarker for StreamError {
5106        type Owned = Self;
5107
5108        #[inline(always)]
5109        fn inline_align(_context: fidl::encoding::Context) -> usize {
5110            std::mem::align_of::<u32>()
5111        }
5112
5113        #[inline(always)]
5114        fn inline_size(_context: fidl::encoding::Context) -> usize {
5115            std::mem::size_of::<u32>()
5116        }
5117
5118        #[inline(always)]
5119        fn encode_is_copy() -> bool {
5120            true
5121        }
5122
5123        #[inline(always)]
5124        fn decode_is_copy() -> bool {
5125            false
5126        }
5127    }
5128
5129    impl fidl::encoding::ValueTypeMarker for StreamError {
5130        type Borrowed<'a> = Self;
5131        #[inline(always)]
5132        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5133            *value
5134        }
5135    }
5136
5137    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StreamError {
5138        #[inline]
5139        unsafe fn encode(
5140            self,
5141            encoder: &mut fidl::encoding::Encoder<'_, D>,
5142            offset: usize,
5143            _depth: fidl::encoding::Depth,
5144        ) -> fidl::Result<()> {
5145            encoder.debug_check_bounds::<Self>(offset);
5146            encoder.write_num(self.into_primitive(), offset);
5147            Ok(())
5148        }
5149    }
5150
5151    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamError {
5152        #[inline(always)]
5153        fn new_empty() -> Self {
5154            Self::Unknown
5155        }
5156
5157        #[inline]
5158        unsafe fn decode(
5159            &mut self,
5160            decoder: &mut fidl::encoding::Decoder<'_, D>,
5161            offset: usize,
5162            _depth: fidl::encoding::Depth,
5163        ) -> fidl::Result<()> {
5164            decoder.debug_check_bounds::<Self>(offset);
5165            let prim = decoder.read_num::<u32>(offset);
5166
5167            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5168            Ok(())
5169        }
5170    }
5171    unsafe impl fidl::encoding::TypeMarker for VideoColorSpace {
5172        type Owned = Self;
5173
5174        #[inline(always)]
5175        fn inline_align(_context: fidl::encoding::Context) -> usize {
5176            std::mem::align_of::<u32>()
5177        }
5178
5179        #[inline(always)]
5180        fn inline_size(_context: fidl::encoding::Context) -> usize {
5181            std::mem::size_of::<u32>()
5182        }
5183
5184        #[inline(always)]
5185        fn encode_is_copy() -> bool {
5186            true
5187        }
5188
5189        #[inline(always)]
5190        fn decode_is_copy() -> bool {
5191            false
5192        }
5193    }
5194
5195    impl fidl::encoding::ValueTypeMarker for VideoColorSpace {
5196        type Borrowed<'a> = Self;
5197        #[inline(always)]
5198        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5199            *value
5200        }
5201    }
5202
5203    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
5204        for VideoColorSpace
5205    {
5206        #[inline]
5207        unsafe fn encode(
5208            self,
5209            encoder: &mut fidl::encoding::Encoder<'_, D>,
5210            offset: usize,
5211            _depth: fidl::encoding::Depth,
5212        ) -> fidl::Result<()> {
5213            encoder.debug_check_bounds::<Self>(offset);
5214            encoder.write_num(self.into_primitive(), offset);
5215            Ok(())
5216        }
5217    }
5218
5219    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoColorSpace {
5220        #[inline(always)]
5221        fn new_empty() -> Self {
5222            Self::Invalid
5223        }
5224
5225        #[inline]
5226        unsafe fn decode(
5227            &mut self,
5228            decoder: &mut fidl::encoding::Decoder<'_, D>,
5229            offset: usize,
5230            _depth: fidl::encoding::Depth,
5231        ) -> fidl::Result<()> {
5232            decoder.debug_check_bounds::<Self>(offset);
5233            let prim = decoder.read_num::<u32>(offset);
5234
5235            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
5236            Ok(())
5237        }
5238    }
5239
5240    impl fidl::encoding::ValueTypeMarker for AacConstantBitRate {
5241        type Borrowed<'a> = &'a Self;
5242        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5243            value
5244        }
5245    }
5246
5247    unsafe impl fidl::encoding::TypeMarker for AacConstantBitRate {
5248        type Owned = Self;
5249
5250        #[inline(always)]
5251        fn inline_align(_context: fidl::encoding::Context) -> usize {
5252            4
5253        }
5254
5255        #[inline(always)]
5256        fn inline_size(_context: fidl::encoding::Context) -> usize {
5257            4
5258        }
5259        #[inline(always)]
5260        fn encode_is_copy() -> bool {
5261            true
5262        }
5263
5264        #[inline(always)]
5265        fn decode_is_copy() -> bool {
5266            true
5267        }
5268    }
5269
5270    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacConstantBitRate, D>
5271        for &AacConstantBitRate
5272    {
5273        #[inline]
5274        unsafe fn encode(
5275            self,
5276            encoder: &mut fidl::encoding::Encoder<'_, D>,
5277            offset: usize,
5278            _depth: fidl::encoding::Depth,
5279        ) -> fidl::Result<()> {
5280            encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5281            unsafe {
5282                // Copy the object into the buffer.
5283                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5284                (buf_ptr as *mut AacConstantBitRate)
5285                    .write_unaligned((self as *const AacConstantBitRate).read());
5286                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5287                // done second because the memcpy will write garbage to these bytes.
5288            }
5289            Ok(())
5290        }
5291    }
5292    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
5293        fidl::encoding::Encode<AacConstantBitRate, D> for (T0,)
5294    {
5295        #[inline]
5296        unsafe fn encode(
5297            self,
5298            encoder: &mut fidl::encoding::Encoder<'_, D>,
5299            offset: usize,
5300            depth: fidl::encoding::Depth,
5301        ) -> fidl::Result<()> {
5302            encoder.debug_check_bounds::<AacConstantBitRate>(offset);
5303            // Zero out padding regions. There's no need to apply masks
5304            // because the unmasked parts will be overwritten by fields.
5305            // Write the fields.
5306            self.0.encode(encoder, offset + 0, depth)?;
5307            Ok(())
5308        }
5309    }
5310
5311    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacConstantBitRate {
5312        #[inline(always)]
5313        fn new_empty() -> Self {
5314            Self { bit_rate: fidl::new_empty!(u32, D) }
5315        }
5316
5317        #[inline]
5318        unsafe fn decode(
5319            &mut self,
5320            decoder: &mut fidl::encoding::Decoder<'_, D>,
5321            offset: usize,
5322            _depth: fidl::encoding::Depth,
5323        ) -> fidl::Result<()> {
5324            decoder.debug_check_bounds::<Self>(offset);
5325            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5326            // Verify that padding bytes are zero.
5327            // Copy from the buffer into the object.
5328            unsafe {
5329                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
5330            }
5331            Ok(())
5332        }
5333    }
5334
5335    impl fidl::encoding::ValueTypeMarker for AacEncoderSettings {
5336        type Borrowed<'a> = &'a Self;
5337        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5338            value
5339        }
5340    }
5341
5342    unsafe impl fidl::encoding::TypeMarker for AacEncoderSettings {
5343        type Owned = Self;
5344
5345        #[inline(always)]
5346        fn inline_align(_context: fidl::encoding::Context) -> usize {
5347            8
5348        }
5349
5350        #[inline(always)]
5351        fn inline_size(_context: fidl::encoding::Context) -> usize {
5352            48
5353        }
5354    }
5355
5356    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacEncoderSettings, D>
5357        for &AacEncoderSettings
5358    {
5359        #[inline]
5360        unsafe fn encode(
5361            self,
5362            encoder: &mut fidl::encoding::Encoder<'_, D>,
5363            offset: usize,
5364            _depth: fidl::encoding::Depth,
5365        ) -> fidl::Result<()> {
5366            encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5367            // Delegate to tuple encoding.
5368            fidl::encoding::Encode::<AacEncoderSettings, D>::encode(
5369                (
5370                    <AacTransport as fidl::encoding::ValueTypeMarker>::borrow(&self.transport),
5371                    <AacChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
5372                    <AacBitRate as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_rate),
5373                    <AacAudioObjectType as fidl::encoding::ValueTypeMarker>::borrow(&self.aot),
5374                ),
5375                encoder,
5376                offset,
5377                _depth,
5378            )
5379        }
5380    }
5381    unsafe impl<
5382            D: fidl::encoding::ResourceDialect,
5383            T0: fidl::encoding::Encode<AacTransport, D>,
5384            T1: fidl::encoding::Encode<AacChannelMode, D>,
5385            T2: fidl::encoding::Encode<AacBitRate, D>,
5386            T3: fidl::encoding::Encode<AacAudioObjectType, D>,
5387        > fidl::encoding::Encode<AacEncoderSettings, D> for (T0, T1, T2, T3)
5388    {
5389        #[inline]
5390        unsafe fn encode(
5391            self,
5392            encoder: &mut fidl::encoding::Encoder<'_, D>,
5393            offset: usize,
5394            depth: fidl::encoding::Depth,
5395        ) -> fidl::Result<()> {
5396            encoder.debug_check_bounds::<AacEncoderSettings>(offset);
5397            // Zero out padding regions. There's no need to apply masks
5398            // because the unmasked parts will be overwritten by fields.
5399            unsafe {
5400                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
5401                (ptr as *mut u64).write_unaligned(0);
5402            }
5403            unsafe {
5404                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
5405                (ptr as *mut u64).write_unaligned(0);
5406            }
5407            // Write the fields.
5408            self.0.encode(encoder, offset + 0, depth)?;
5409            self.1.encode(encoder, offset + 16, depth)?;
5410            self.2.encode(encoder, offset + 24, depth)?;
5411            self.3.encode(encoder, offset + 40, depth)?;
5412            Ok(())
5413        }
5414    }
5415
5416    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacEncoderSettings {
5417        #[inline(always)]
5418        fn new_empty() -> Self {
5419            Self {
5420                transport: fidl::new_empty!(AacTransport, D),
5421                channel_mode: fidl::new_empty!(AacChannelMode, D),
5422                bit_rate: fidl::new_empty!(AacBitRate, D),
5423                aot: fidl::new_empty!(AacAudioObjectType, D),
5424            }
5425        }
5426
5427        #[inline]
5428        unsafe fn decode(
5429            &mut self,
5430            decoder: &mut fidl::encoding::Decoder<'_, D>,
5431            offset: usize,
5432            _depth: fidl::encoding::Depth,
5433        ) -> fidl::Result<()> {
5434            decoder.debug_check_bounds::<Self>(offset);
5435            // Verify that padding bytes are zero.
5436            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
5437            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5438            let mask = 0xffffffff00000000u64;
5439            let maskedval = padval & mask;
5440            if maskedval != 0 {
5441                return Err(fidl::Error::NonZeroPadding {
5442                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
5443                });
5444            }
5445            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
5446            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5447            let mask = 0xffffffff00000000u64;
5448            let maskedval = padval & mask;
5449            if maskedval != 0 {
5450                return Err(fidl::Error::NonZeroPadding {
5451                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
5452                });
5453            }
5454            fidl::decode!(AacTransport, D, &mut self.transport, decoder, offset + 0, _depth)?;
5455            fidl::decode!(AacChannelMode, D, &mut self.channel_mode, decoder, offset + 16, _depth)?;
5456            fidl::decode!(AacBitRate, D, &mut self.bit_rate, decoder, offset + 24, _depth)?;
5457            fidl::decode!(AacAudioObjectType, D, &mut self.aot, decoder, offset + 40, _depth)?;
5458            Ok(())
5459        }
5460    }
5461
5462    impl fidl::encoding::ValueTypeMarker for AacTransportAdts {
5463        type Borrowed<'a> = &'a Self;
5464        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5465            value
5466        }
5467    }
5468
5469    unsafe impl fidl::encoding::TypeMarker for AacTransportAdts {
5470        type Owned = Self;
5471
5472        #[inline(always)]
5473        fn inline_align(_context: fidl::encoding::Context) -> usize {
5474            1
5475        }
5476
5477        #[inline(always)]
5478        fn inline_size(_context: fidl::encoding::Context) -> usize {
5479            1
5480        }
5481    }
5482
5483    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportAdts, D>
5484        for &AacTransportAdts
5485    {
5486        #[inline]
5487        unsafe fn encode(
5488            self,
5489            encoder: &mut fidl::encoding::Encoder<'_, D>,
5490            offset: usize,
5491            _depth: fidl::encoding::Depth,
5492        ) -> fidl::Result<()> {
5493            encoder.debug_check_bounds::<AacTransportAdts>(offset);
5494            encoder.write_num(0u8, offset);
5495            Ok(())
5496        }
5497    }
5498
5499    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportAdts {
5500        #[inline(always)]
5501        fn new_empty() -> Self {
5502            Self
5503        }
5504
5505        #[inline]
5506        unsafe fn decode(
5507            &mut self,
5508            decoder: &mut fidl::encoding::Decoder<'_, D>,
5509            offset: usize,
5510            _depth: fidl::encoding::Depth,
5511        ) -> fidl::Result<()> {
5512            decoder.debug_check_bounds::<Self>(offset);
5513            match decoder.read_num::<u8>(offset) {
5514                0 => Ok(()),
5515                _ => Err(fidl::Error::Invalid),
5516            }
5517        }
5518    }
5519
5520    impl fidl::encoding::ValueTypeMarker for AacTransportLatm {
5521        type Borrowed<'a> = &'a Self;
5522        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5523            value
5524        }
5525    }
5526
5527    unsafe impl fidl::encoding::TypeMarker for AacTransportLatm {
5528        type Owned = Self;
5529
5530        #[inline(always)]
5531        fn inline_align(_context: fidl::encoding::Context) -> usize {
5532            1
5533        }
5534
5535        #[inline(always)]
5536        fn inline_size(_context: fidl::encoding::Context) -> usize {
5537            1
5538        }
5539    }
5540
5541    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportLatm, D>
5542        for &AacTransportLatm
5543    {
5544        #[inline]
5545        unsafe fn encode(
5546            self,
5547            encoder: &mut fidl::encoding::Encoder<'_, D>,
5548            offset: usize,
5549            _depth: fidl::encoding::Depth,
5550        ) -> fidl::Result<()> {
5551            encoder.debug_check_bounds::<AacTransportLatm>(offset);
5552            // Delegate to tuple encoding.
5553            fidl::encoding::Encode::<AacTransportLatm, D>::encode(
5554                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.mux_config_present),),
5555                encoder,
5556                offset,
5557                _depth,
5558            )
5559        }
5560    }
5561    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
5562        fidl::encoding::Encode<AacTransportLatm, D> for (T0,)
5563    {
5564        #[inline]
5565        unsafe fn encode(
5566            self,
5567            encoder: &mut fidl::encoding::Encoder<'_, D>,
5568            offset: usize,
5569            depth: fidl::encoding::Depth,
5570        ) -> fidl::Result<()> {
5571            encoder.debug_check_bounds::<AacTransportLatm>(offset);
5572            // Zero out padding regions. There's no need to apply masks
5573            // because the unmasked parts will be overwritten by fields.
5574            // Write the fields.
5575            self.0.encode(encoder, offset + 0, depth)?;
5576            Ok(())
5577        }
5578    }
5579
5580    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportLatm {
5581        #[inline(always)]
5582        fn new_empty() -> Self {
5583            Self { mux_config_present: fidl::new_empty!(bool, D) }
5584        }
5585
5586        #[inline]
5587        unsafe fn decode(
5588            &mut self,
5589            decoder: &mut fidl::encoding::Decoder<'_, D>,
5590            offset: usize,
5591            _depth: fidl::encoding::Depth,
5592        ) -> fidl::Result<()> {
5593            decoder.debug_check_bounds::<Self>(offset);
5594            // Verify that padding bytes are zero.
5595            fidl::decode!(bool, D, &mut self.mux_config_present, decoder, offset + 0, _depth)?;
5596            Ok(())
5597        }
5598    }
5599
5600    impl fidl::encoding::ValueTypeMarker for AacTransportRaw {
5601        type Borrowed<'a> = &'a Self;
5602        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5603            value
5604        }
5605    }
5606
5607    unsafe impl fidl::encoding::TypeMarker for AacTransportRaw {
5608        type Owned = Self;
5609
5610        #[inline(always)]
5611        fn inline_align(_context: fidl::encoding::Context) -> usize {
5612            1
5613        }
5614
5615        #[inline(always)]
5616        fn inline_size(_context: fidl::encoding::Context) -> usize {
5617            1
5618        }
5619    }
5620
5621    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransportRaw, D>
5622        for &AacTransportRaw
5623    {
5624        #[inline]
5625        unsafe fn encode(
5626            self,
5627            encoder: &mut fidl::encoding::Encoder<'_, D>,
5628            offset: usize,
5629            _depth: fidl::encoding::Depth,
5630        ) -> fidl::Result<()> {
5631            encoder.debug_check_bounds::<AacTransportRaw>(offset);
5632            encoder.write_num(0u8, offset);
5633            Ok(())
5634        }
5635    }
5636
5637    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransportRaw {
5638        #[inline(always)]
5639        fn new_empty() -> Self {
5640            Self
5641        }
5642
5643        #[inline]
5644        unsafe fn decode(
5645            &mut self,
5646            decoder: &mut fidl::encoding::Decoder<'_, D>,
5647            offset: usize,
5648            _depth: fidl::encoding::Depth,
5649        ) -> fidl::Result<()> {
5650            decoder.debug_check_bounds::<Self>(offset);
5651            match decoder.read_num::<u8>(offset) {
5652                0 => Ok(()),
5653                _ => Err(fidl::Error::Invalid),
5654            }
5655        }
5656    }
5657
5658    impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivityResponse {
5659        type Borrowed<'a> = &'a Self;
5660        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5661            value
5662        }
5663    }
5664
5665    unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivityResponse {
5666        type Owned = Self;
5667
5668        #[inline(always)]
5669        fn inline_align(_context: fidl::encoding::Context) -> usize {
5670            8
5671        }
5672
5673        #[inline(always)]
5674        fn inline_size(_context: fidl::encoding::Context) -> usize {
5675            16
5676        }
5677    }
5678
5679    unsafe impl<D: fidl::encoding::ResourceDialect>
5680        fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D>
5681        for &ActivityReporterWatchCaptureActivityResponse
5682    {
5683        #[inline]
5684        unsafe fn encode(
5685            self,
5686            encoder: &mut fidl::encoding::Encoder<'_, D>,
5687            offset: usize,
5688            _depth: fidl::encoding::Depth,
5689        ) -> fidl::Result<()> {
5690            encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5691            // Delegate to tuple encoding.
5692            fidl::encoding::Encode::<ActivityReporterWatchCaptureActivityResponse, D>::encode(
5693                (
5694                    <fidl::encoding::Vector<AudioCaptureUsage, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5695                ),
5696                encoder, offset, _depth
5697            )
5698        }
5699    }
5700    unsafe impl<
5701            D: fidl::encoding::ResourceDialect,
5702            T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage, 4>, D>,
5703        > fidl::encoding::Encode<ActivityReporterWatchCaptureActivityResponse, D> for (T0,)
5704    {
5705        #[inline]
5706        unsafe fn encode(
5707            self,
5708            encoder: &mut fidl::encoding::Encoder<'_, D>,
5709            offset: usize,
5710            depth: fidl::encoding::Depth,
5711        ) -> fidl::Result<()> {
5712            encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivityResponse>(offset);
5713            // Zero out padding regions. There's no need to apply masks
5714            // because the unmasked parts will be overwritten by fields.
5715            // Write the fields.
5716            self.0.encode(encoder, offset + 0, depth)?;
5717            Ok(())
5718        }
5719    }
5720
5721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5722        for ActivityReporterWatchCaptureActivityResponse
5723    {
5724        #[inline(always)]
5725        fn new_empty() -> Self {
5726            Self {
5727                active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D),
5728            }
5729        }
5730
5731        #[inline]
5732        unsafe fn decode(
5733            &mut self,
5734            decoder: &mut fidl::encoding::Decoder<'_, D>,
5735            offset: usize,
5736            _depth: fidl::encoding::Depth,
5737        ) -> fidl::Result<()> {
5738            decoder.debug_check_bounds::<Self>(offset);
5739            // Verify that padding bytes are zero.
5740            fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage, 4>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5741            Ok(())
5742        }
5743    }
5744
5745    impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivityResponse {
5746        type Borrowed<'a> = &'a Self;
5747        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5748            value
5749        }
5750    }
5751
5752    unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivityResponse {
5753        type Owned = Self;
5754
5755        #[inline(always)]
5756        fn inline_align(_context: fidl::encoding::Context) -> usize {
5757            8
5758        }
5759
5760        #[inline(always)]
5761        fn inline_size(_context: fidl::encoding::Context) -> usize {
5762            16
5763        }
5764    }
5765
5766    unsafe impl<D: fidl::encoding::ResourceDialect>
5767        fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D>
5768        for &ActivityReporterWatchRenderActivityResponse
5769    {
5770        #[inline]
5771        unsafe fn encode(
5772            self,
5773            encoder: &mut fidl::encoding::Encoder<'_, D>,
5774            offset: usize,
5775            _depth: fidl::encoding::Depth,
5776        ) -> fidl::Result<()> {
5777            encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5778            // Delegate to tuple encoding.
5779            fidl::encoding::Encode::<ActivityReporterWatchRenderActivityResponse, D>::encode(
5780                (
5781                    <fidl::encoding::Vector<AudioRenderUsage, 5> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5782                ),
5783                encoder, offset, _depth
5784            )
5785        }
5786    }
5787    unsafe impl<
5788            D: fidl::encoding::ResourceDialect,
5789            T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage, 5>, D>,
5790        > fidl::encoding::Encode<ActivityReporterWatchRenderActivityResponse, D> for (T0,)
5791    {
5792        #[inline]
5793        unsafe fn encode(
5794            self,
5795            encoder: &mut fidl::encoding::Encoder<'_, D>,
5796            offset: usize,
5797            depth: fidl::encoding::Depth,
5798        ) -> fidl::Result<()> {
5799            encoder.debug_check_bounds::<ActivityReporterWatchRenderActivityResponse>(offset);
5800            // Zero out padding regions. There's no need to apply masks
5801            // because the unmasked parts will be overwritten by fields.
5802            // Write the fields.
5803            self.0.encode(encoder, offset + 0, depth)?;
5804            Ok(())
5805        }
5806    }
5807
5808    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5809        for ActivityReporterWatchRenderActivityResponse
5810    {
5811        #[inline(always)]
5812        fn new_empty() -> Self {
5813            Self { active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage, 5>, D) }
5814        }
5815
5816        #[inline]
5817        unsafe fn decode(
5818            &mut self,
5819            decoder: &mut fidl::encoding::Decoder<'_, D>,
5820            offset: usize,
5821            _depth: fidl::encoding::Depth,
5822        ) -> fidl::Result<()> {
5823            decoder.debug_check_bounds::<Self>(offset);
5824            // Verify that padding bytes are zero.
5825            fidl::decode!(fidl::encoding::Vector<AudioRenderUsage, 5>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5826            Ok(())
5827        }
5828    }
5829
5830    impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchCaptureActivity2Response {
5831        type Borrowed<'a> = &'a Self;
5832        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5833            value
5834        }
5835    }
5836
5837    unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchCaptureActivity2Response {
5838        type Owned = Self;
5839
5840        #[inline(always)]
5841        fn inline_align(_context: fidl::encoding::Context) -> usize {
5842            8
5843        }
5844
5845        #[inline(always)]
5846        fn inline_size(_context: fidl::encoding::Context) -> usize {
5847            16
5848        }
5849    }
5850
5851    unsafe impl<D: fidl::encoding::ResourceDialect>
5852        fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D>
5853        for &ActivityReporterWatchCaptureActivity2Response
5854    {
5855        #[inline]
5856        unsafe fn encode(
5857            self,
5858            encoder: &mut fidl::encoding::Encoder<'_, D>,
5859            offset: usize,
5860            _depth: fidl::encoding::Depth,
5861        ) -> fidl::Result<()> {
5862            encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5863            // Delegate to tuple encoding.
5864            fidl::encoding::Encode::<ActivityReporterWatchCaptureActivity2Response, D>::encode(
5865                (
5866                    <fidl::encoding::Vector<AudioCaptureUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5867                ),
5868                encoder, offset, _depth
5869            )
5870        }
5871    }
5872    unsafe impl<
5873            D: fidl::encoding::ResourceDialect,
5874            T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioCaptureUsage2, 8>, D>,
5875        > fidl::encoding::Encode<ActivityReporterWatchCaptureActivity2Response, D> for (T0,)
5876    {
5877        #[inline]
5878        unsafe fn encode(
5879            self,
5880            encoder: &mut fidl::encoding::Encoder<'_, D>,
5881            offset: usize,
5882            depth: fidl::encoding::Depth,
5883        ) -> fidl::Result<()> {
5884            encoder.debug_check_bounds::<ActivityReporterWatchCaptureActivity2Response>(offset);
5885            // Zero out padding regions. There's no need to apply masks
5886            // because the unmasked parts will be overwritten by fields.
5887            // Write the fields.
5888            self.0.encode(encoder, offset + 0, depth)?;
5889            Ok(())
5890        }
5891    }
5892
5893    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5894        for ActivityReporterWatchCaptureActivity2Response
5895    {
5896        #[inline(always)]
5897        fn new_empty() -> Self {
5898            Self {
5899                active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D),
5900            }
5901        }
5902
5903        #[inline]
5904        unsafe fn decode(
5905            &mut self,
5906            decoder: &mut fidl::encoding::Decoder<'_, D>,
5907            offset: usize,
5908            _depth: fidl::encoding::Depth,
5909        ) -> fidl::Result<()> {
5910            decoder.debug_check_bounds::<Self>(offset);
5911            // Verify that padding bytes are zero.
5912            fidl::decode!(fidl::encoding::Vector<AudioCaptureUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
5913            Ok(())
5914        }
5915    }
5916
5917    impl fidl::encoding::ValueTypeMarker for ActivityReporterWatchRenderActivity2Response {
5918        type Borrowed<'a> = &'a Self;
5919        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5920            value
5921        }
5922    }
5923
5924    unsafe impl fidl::encoding::TypeMarker for ActivityReporterWatchRenderActivity2Response {
5925        type Owned = Self;
5926
5927        #[inline(always)]
5928        fn inline_align(_context: fidl::encoding::Context) -> usize {
5929            8
5930        }
5931
5932        #[inline(always)]
5933        fn inline_size(_context: fidl::encoding::Context) -> usize {
5934            16
5935        }
5936    }
5937
5938    unsafe impl<D: fidl::encoding::ResourceDialect>
5939        fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D>
5940        for &ActivityReporterWatchRenderActivity2Response
5941    {
5942        #[inline]
5943        unsafe fn encode(
5944            self,
5945            encoder: &mut fidl::encoding::Encoder<'_, D>,
5946            offset: usize,
5947            _depth: fidl::encoding::Depth,
5948        ) -> fidl::Result<()> {
5949            encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5950            // Delegate to tuple encoding.
5951            fidl::encoding::Encode::<ActivityReporterWatchRenderActivity2Response, D>::encode(
5952                (
5953                    <fidl::encoding::Vector<AudioRenderUsage2, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_usages),
5954                ),
5955                encoder, offset, _depth
5956            )
5957        }
5958    }
5959    unsafe impl<
5960            D: fidl::encoding::ResourceDialect,
5961            T0: fidl::encoding::Encode<fidl::encoding::Vector<AudioRenderUsage2, 8>, D>,
5962        > fidl::encoding::Encode<ActivityReporterWatchRenderActivity2Response, D> for (T0,)
5963    {
5964        #[inline]
5965        unsafe fn encode(
5966            self,
5967            encoder: &mut fidl::encoding::Encoder<'_, D>,
5968            offset: usize,
5969            depth: fidl::encoding::Depth,
5970        ) -> fidl::Result<()> {
5971            encoder.debug_check_bounds::<ActivityReporterWatchRenderActivity2Response>(offset);
5972            // Zero out padding regions. There's no need to apply masks
5973            // because the unmasked parts will be overwritten by fields.
5974            // Write the fields.
5975            self.0.encode(encoder, offset + 0, depth)?;
5976            Ok(())
5977        }
5978    }
5979
5980    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5981        for ActivityReporterWatchRenderActivity2Response
5982    {
5983        #[inline(always)]
5984        fn new_empty() -> Self {
5985            Self {
5986                active_usages: fidl::new_empty!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D),
5987            }
5988        }
5989
5990        #[inline]
5991        unsafe fn decode(
5992            &mut self,
5993            decoder: &mut fidl::encoding::Decoder<'_, D>,
5994            offset: usize,
5995            _depth: fidl::encoding::Depth,
5996        ) -> fidl::Result<()> {
5997            decoder.debug_check_bounds::<Self>(offset);
5998            // Verify that padding bytes are zero.
5999            fidl::decode!(fidl::encoding::Vector<AudioRenderUsage2, 8>, D, &mut self.active_usages, decoder, offset + 0, _depth)?;
6000            Ok(())
6001        }
6002    }
6003
6004    impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtRequest {
6005        type Borrowed<'a> = &'a Self;
6006        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6007            value
6008        }
6009    }
6010
6011    unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtRequest {
6012        type Owned = Self;
6013
6014        #[inline(always)]
6015        fn inline_align(_context: fidl::encoding::Context) -> usize {
6016            4
6017        }
6018
6019        #[inline(always)]
6020        fn inline_size(_context: fidl::encoding::Context) -> usize {
6021            12
6022        }
6023        #[inline(always)]
6024        fn encode_is_copy() -> bool {
6025            true
6026        }
6027
6028        #[inline(always)]
6029        fn decode_is_copy() -> bool {
6030            true
6031        }
6032    }
6033
6034    unsafe impl<D: fidl::encoding::ResourceDialect>
6035        fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D>
6036        for &AudioCapturerCaptureAtRequest
6037    {
6038        #[inline]
6039        unsafe fn encode(
6040            self,
6041            encoder: &mut fidl::encoding::Encoder<'_, D>,
6042            offset: usize,
6043            _depth: fidl::encoding::Depth,
6044        ) -> fidl::Result<()> {
6045            encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
6046            unsafe {
6047                // Copy the object into the buffer.
6048                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6049                (buf_ptr as *mut AudioCapturerCaptureAtRequest)
6050                    .write_unaligned((self as *const AudioCapturerCaptureAtRequest).read());
6051                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6052                // done second because the memcpy will write garbage to these bytes.
6053            }
6054            Ok(())
6055        }
6056    }
6057    unsafe impl<
6058            D: fidl::encoding::ResourceDialect,
6059            T0: fidl::encoding::Encode<u32, D>,
6060            T1: fidl::encoding::Encode<u32, D>,
6061            T2: fidl::encoding::Encode<u32, D>,
6062        > fidl::encoding::Encode<AudioCapturerCaptureAtRequest, D> for (T0, T1, T2)
6063    {
6064        #[inline]
6065        unsafe fn encode(
6066            self,
6067            encoder: &mut fidl::encoding::Encoder<'_, D>,
6068            offset: usize,
6069            depth: fidl::encoding::Depth,
6070        ) -> fidl::Result<()> {
6071            encoder.debug_check_bounds::<AudioCapturerCaptureAtRequest>(offset);
6072            // Zero out padding regions. There's no need to apply masks
6073            // because the unmasked parts will be overwritten by fields.
6074            // Write the fields.
6075            self.0.encode(encoder, offset + 0, depth)?;
6076            self.1.encode(encoder, offset + 4, depth)?;
6077            self.2.encode(encoder, offset + 8, depth)?;
6078            Ok(())
6079        }
6080    }
6081
6082    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6083        for AudioCapturerCaptureAtRequest
6084    {
6085        #[inline(always)]
6086        fn new_empty() -> Self {
6087            Self {
6088                payload_buffer_id: fidl::new_empty!(u32, D),
6089                payload_offset: fidl::new_empty!(u32, D),
6090                frames: fidl::new_empty!(u32, D),
6091            }
6092        }
6093
6094        #[inline]
6095        unsafe fn decode(
6096            &mut self,
6097            decoder: &mut fidl::encoding::Decoder<'_, D>,
6098            offset: usize,
6099            _depth: fidl::encoding::Depth,
6100        ) -> fidl::Result<()> {
6101            decoder.debug_check_bounds::<Self>(offset);
6102            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6103            // Verify that padding bytes are zero.
6104            // Copy from the buffer into the object.
6105            unsafe {
6106                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
6107            }
6108            Ok(())
6109        }
6110    }
6111
6112    impl fidl::encoding::ValueTypeMarker for AudioCapturerCaptureAtResponse {
6113        type Borrowed<'a> = &'a Self;
6114        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6115            value
6116        }
6117    }
6118
6119    unsafe impl fidl::encoding::TypeMarker for AudioCapturerCaptureAtResponse {
6120        type Owned = Self;
6121
6122        #[inline(always)]
6123        fn inline_align(_context: fidl::encoding::Context) -> usize {
6124            8
6125        }
6126
6127        #[inline(always)]
6128        fn inline_size(_context: fidl::encoding::Context) -> usize {
6129            56
6130        }
6131    }
6132
6133    unsafe impl<D: fidl::encoding::ResourceDialect>
6134        fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D>
6135        for &AudioCapturerCaptureAtResponse
6136    {
6137        #[inline]
6138        unsafe fn encode(
6139            self,
6140            encoder: &mut fidl::encoding::Encoder<'_, D>,
6141            offset: usize,
6142            _depth: fidl::encoding::Depth,
6143        ) -> fidl::Result<()> {
6144            encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
6145            unsafe {
6146                // Copy the object into the buffer.
6147                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6148                (buf_ptr as *mut AudioCapturerCaptureAtResponse)
6149                    .write_unaligned((self as *const AudioCapturerCaptureAtResponse).read());
6150                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6151                // done second because the memcpy will write garbage to these bytes.
6152                let padding_ptr = buf_ptr.offset(8) as *mut u64;
6153                let padding_mask = 0xffffffff00000000u64;
6154                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
6155                let padding_ptr = buf_ptr.offset(32) as *mut u64;
6156                let padding_mask = 0xffffffff00000000u64;
6157                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
6158            }
6159            Ok(())
6160        }
6161    }
6162    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
6163        fidl::encoding::Encode<AudioCapturerCaptureAtResponse, D> for (T0,)
6164    {
6165        #[inline]
6166        unsafe fn encode(
6167            self,
6168            encoder: &mut fidl::encoding::Encoder<'_, D>,
6169            offset: usize,
6170            depth: fidl::encoding::Depth,
6171        ) -> fidl::Result<()> {
6172            encoder.debug_check_bounds::<AudioCapturerCaptureAtResponse>(offset);
6173            // Zero out padding regions. There's no need to apply masks
6174            // because the unmasked parts will be overwritten by fields.
6175            // Write the fields.
6176            self.0.encode(encoder, offset + 0, depth)?;
6177            Ok(())
6178        }
6179    }
6180
6181    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6182        for AudioCapturerCaptureAtResponse
6183    {
6184        #[inline(always)]
6185        fn new_empty() -> Self {
6186            Self { captured_packet: fidl::new_empty!(StreamPacket, D) }
6187        }
6188
6189        #[inline]
6190        unsafe fn decode(
6191            &mut self,
6192            decoder: &mut fidl::encoding::Decoder<'_, D>,
6193            offset: usize,
6194            _depth: fidl::encoding::Depth,
6195        ) -> fidl::Result<()> {
6196            decoder.debug_check_bounds::<Self>(offset);
6197            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6198            // Verify that padding bytes are zero.
6199            let ptr = unsafe { buf_ptr.offset(8) };
6200            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6201            let mask = 0xffffffff00000000u64;
6202            let maskedval = padval & mask;
6203            if maskedval != 0 {
6204                return Err(fidl::Error::NonZeroPadding {
6205                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
6206                });
6207            }
6208            let ptr = unsafe { buf_ptr.offset(32) };
6209            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6210            let mask = 0xffffffff00000000u64;
6211            let maskedval = padval & mask;
6212            if maskedval != 0 {
6213                return Err(fidl::Error::NonZeroPadding {
6214                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
6215                });
6216            }
6217            // Copy from the buffer into the object.
6218            unsafe {
6219                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
6220            }
6221            Ok(())
6222        }
6223    }
6224
6225    impl fidl::encoding::ValueTypeMarker for AudioCapturerGetStreamTypeResponse {
6226        type Borrowed<'a> = &'a Self;
6227        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6228            value
6229        }
6230    }
6231
6232    unsafe impl fidl::encoding::TypeMarker for AudioCapturerGetStreamTypeResponse {
6233        type Owned = Self;
6234
6235        #[inline(always)]
6236        fn inline_align(_context: fidl::encoding::Context) -> usize {
6237            8
6238        }
6239
6240        #[inline(always)]
6241        fn inline_size(_context: fidl::encoding::Context) -> usize {
6242            48
6243        }
6244    }
6245
6246    unsafe impl<D: fidl::encoding::ResourceDialect>
6247        fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D>
6248        for &AudioCapturerGetStreamTypeResponse
6249    {
6250        #[inline]
6251        unsafe fn encode(
6252            self,
6253            encoder: &mut fidl::encoding::Encoder<'_, D>,
6254            offset: usize,
6255            _depth: fidl::encoding::Depth,
6256        ) -> fidl::Result<()> {
6257            encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6258            // Delegate to tuple encoding.
6259            fidl::encoding::Encode::<AudioCapturerGetStreamTypeResponse, D>::encode(
6260                (<StreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6261                encoder,
6262                offset,
6263                _depth,
6264            )
6265        }
6266    }
6267    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamType, D>>
6268        fidl::encoding::Encode<AudioCapturerGetStreamTypeResponse, D> for (T0,)
6269    {
6270        #[inline]
6271        unsafe fn encode(
6272            self,
6273            encoder: &mut fidl::encoding::Encoder<'_, D>,
6274            offset: usize,
6275            depth: fidl::encoding::Depth,
6276        ) -> fidl::Result<()> {
6277            encoder.debug_check_bounds::<AudioCapturerGetStreamTypeResponse>(offset);
6278            // Zero out padding regions. There's no need to apply masks
6279            // because the unmasked parts will be overwritten by fields.
6280            // Write the fields.
6281            self.0.encode(encoder, offset + 0, depth)?;
6282            Ok(())
6283        }
6284    }
6285
6286    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6287        for AudioCapturerGetStreamTypeResponse
6288    {
6289        #[inline(always)]
6290        fn new_empty() -> Self {
6291            Self { stream_type: fidl::new_empty!(StreamType, D) }
6292        }
6293
6294        #[inline]
6295        unsafe fn decode(
6296            &mut self,
6297            decoder: &mut fidl::encoding::Decoder<'_, D>,
6298            offset: usize,
6299            _depth: fidl::encoding::Depth,
6300        ) -> fidl::Result<()> {
6301            decoder.debug_check_bounds::<Self>(offset);
6302            // Verify that padding bytes are zero.
6303            fidl::decode!(StreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6304            Ok(())
6305        }
6306    }
6307
6308    impl fidl::encoding::ValueTypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6309        type Borrowed<'a> = &'a Self;
6310        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6311            value
6312        }
6313    }
6314
6315    unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetPcmStreamTypeRequest {
6316        type Owned = Self;
6317
6318        #[inline(always)]
6319        fn inline_align(_context: fidl::encoding::Context) -> usize {
6320            4
6321        }
6322
6323        #[inline(always)]
6324        fn inline_size(_context: fidl::encoding::Context) -> usize {
6325            12
6326        }
6327    }
6328
6329    unsafe impl<D: fidl::encoding::ResourceDialect>
6330        fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D>
6331        for &AudioCapturerSetPcmStreamTypeRequest
6332    {
6333        #[inline]
6334        unsafe fn encode(
6335            self,
6336            encoder: &mut fidl::encoding::Encoder<'_, D>,
6337            offset: usize,
6338            _depth: fidl::encoding::Depth,
6339        ) -> fidl::Result<()> {
6340            encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6341            // Delegate to tuple encoding.
6342            fidl::encoding::Encode::<AudioCapturerSetPcmStreamTypeRequest, D>::encode(
6343                (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),),
6344                encoder,
6345                offset,
6346                _depth,
6347            )
6348        }
6349    }
6350    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
6351        fidl::encoding::Encode<AudioCapturerSetPcmStreamTypeRequest, D> for (T0,)
6352    {
6353        #[inline]
6354        unsafe fn encode(
6355            self,
6356            encoder: &mut fidl::encoding::Encoder<'_, D>,
6357            offset: usize,
6358            depth: fidl::encoding::Depth,
6359        ) -> fidl::Result<()> {
6360            encoder.debug_check_bounds::<AudioCapturerSetPcmStreamTypeRequest>(offset);
6361            // Zero out padding regions. There's no need to apply masks
6362            // because the unmasked parts will be overwritten by fields.
6363            // Write the fields.
6364            self.0.encode(encoder, offset + 0, depth)?;
6365            Ok(())
6366        }
6367    }
6368
6369    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6370        for AudioCapturerSetPcmStreamTypeRequest
6371    {
6372        #[inline(always)]
6373        fn new_empty() -> Self {
6374            Self { stream_type: fidl::new_empty!(AudioStreamType, D) }
6375        }
6376
6377        #[inline]
6378        unsafe fn decode(
6379            &mut self,
6380            decoder: &mut fidl::encoding::Decoder<'_, D>,
6381            offset: usize,
6382            _depth: fidl::encoding::Depth,
6383        ) -> fidl::Result<()> {
6384            decoder.debug_check_bounds::<Self>(offset);
6385            // Verify that padding bytes are zero.
6386            fidl::decode!(AudioStreamType, D, &mut self.stream_type, decoder, offset + 0, _depth)?;
6387            Ok(())
6388        }
6389    }
6390
6391    impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsage2Request {
6392        type Borrowed<'a> = &'a Self;
6393        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6394            value
6395        }
6396    }
6397
6398    unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsage2Request {
6399        type Owned = Self;
6400
6401        #[inline(always)]
6402        fn inline_align(_context: fidl::encoding::Context) -> usize {
6403            4
6404        }
6405
6406        #[inline(always)]
6407        fn inline_size(_context: fidl::encoding::Context) -> usize {
6408            4
6409        }
6410    }
6411
6412    unsafe impl<D: fidl::encoding::ResourceDialect>
6413        fidl::encoding::Encode<AudioCapturerSetUsage2Request, D>
6414        for &AudioCapturerSetUsage2Request
6415    {
6416        #[inline]
6417        unsafe fn encode(
6418            self,
6419            encoder: &mut fidl::encoding::Encoder<'_, D>,
6420            offset: usize,
6421            _depth: fidl::encoding::Depth,
6422        ) -> fidl::Result<()> {
6423            encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6424            // Delegate to tuple encoding.
6425            fidl::encoding::Encode::<AudioCapturerSetUsage2Request, D>::encode(
6426                (<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6427                encoder,
6428                offset,
6429                _depth,
6430            )
6431        }
6432    }
6433    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage2, D>>
6434        fidl::encoding::Encode<AudioCapturerSetUsage2Request, D> for (T0,)
6435    {
6436        #[inline]
6437        unsafe fn encode(
6438            self,
6439            encoder: &mut fidl::encoding::Encoder<'_, D>,
6440            offset: usize,
6441            depth: fidl::encoding::Depth,
6442        ) -> fidl::Result<()> {
6443            encoder.debug_check_bounds::<AudioCapturerSetUsage2Request>(offset);
6444            // Zero out padding regions. There's no need to apply masks
6445            // because the unmasked parts will be overwritten by fields.
6446            // Write the fields.
6447            self.0.encode(encoder, offset + 0, depth)?;
6448            Ok(())
6449        }
6450    }
6451
6452    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6453        for AudioCapturerSetUsage2Request
6454    {
6455        #[inline(always)]
6456        fn new_empty() -> Self {
6457            Self { usage: fidl::new_empty!(AudioCaptureUsage2, D) }
6458        }
6459
6460        #[inline]
6461        unsafe fn decode(
6462            &mut self,
6463            decoder: &mut fidl::encoding::Decoder<'_, D>,
6464            offset: usize,
6465            _depth: fidl::encoding::Depth,
6466        ) -> fidl::Result<()> {
6467            decoder.debug_check_bounds::<Self>(offset);
6468            // Verify that padding bytes are zero.
6469            fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
6470            Ok(())
6471        }
6472    }
6473
6474    impl fidl::encoding::ValueTypeMarker for AudioCapturerSetUsageRequest {
6475        type Borrowed<'a> = &'a Self;
6476        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6477            value
6478        }
6479    }
6480
6481    unsafe impl fidl::encoding::TypeMarker for AudioCapturerSetUsageRequest {
6482        type Owned = Self;
6483
6484        #[inline(always)]
6485        fn inline_align(_context: fidl::encoding::Context) -> usize {
6486            4
6487        }
6488
6489        #[inline(always)]
6490        fn inline_size(_context: fidl::encoding::Context) -> usize {
6491            4
6492        }
6493    }
6494
6495    unsafe impl<D: fidl::encoding::ResourceDialect>
6496        fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for &AudioCapturerSetUsageRequest
6497    {
6498        #[inline]
6499        unsafe fn encode(
6500            self,
6501            encoder: &mut fidl::encoding::Encoder<'_, D>,
6502            offset: usize,
6503            _depth: fidl::encoding::Depth,
6504        ) -> fidl::Result<()> {
6505            encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6506            // Delegate to tuple encoding.
6507            fidl::encoding::Encode::<AudioCapturerSetUsageRequest, D>::encode(
6508                (<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
6509                encoder,
6510                offset,
6511                _depth,
6512            )
6513        }
6514    }
6515    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioCaptureUsage, D>>
6516        fidl::encoding::Encode<AudioCapturerSetUsageRequest, D> for (T0,)
6517    {
6518        #[inline]
6519        unsafe fn encode(
6520            self,
6521            encoder: &mut fidl::encoding::Encoder<'_, D>,
6522            offset: usize,
6523            depth: fidl::encoding::Depth,
6524        ) -> fidl::Result<()> {
6525            encoder.debug_check_bounds::<AudioCapturerSetUsageRequest>(offset);
6526            // Zero out padding regions. There's no need to apply masks
6527            // because the unmasked parts will be overwritten by fields.
6528            // Write the fields.
6529            self.0.encode(encoder, offset + 0, depth)?;
6530            Ok(())
6531        }
6532    }
6533
6534    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6535        for AudioCapturerSetUsageRequest
6536    {
6537        #[inline(always)]
6538        fn new_empty() -> Self {
6539            Self { usage: fidl::new_empty!(AudioCaptureUsage, D) }
6540        }
6541
6542        #[inline]
6543        unsafe fn decode(
6544            &mut self,
6545            decoder: &mut fidl::encoding::Decoder<'_, D>,
6546            offset: usize,
6547            _depth: fidl::encoding::Depth,
6548        ) -> fidl::Result<()> {
6549            decoder.debug_check_bounds::<Self>(offset);
6550            // Verify that padding bytes are zero.
6551            fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
6552            Ok(())
6553        }
6554    }
6555
6556    impl fidl::encoding::ValueTypeMarker for AudioCapturerStartAsyncCaptureRequest {
6557        type Borrowed<'a> = &'a Self;
6558        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6559            value
6560        }
6561    }
6562
6563    unsafe impl fidl::encoding::TypeMarker for AudioCapturerStartAsyncCaptureRequest {
6564        type Owned = Self;
6565
6566        #[inline(always)]
6567        fn inline_align(_context: fidl::encoding::Context) -> usize {
6568            4
6569        }
6570
6571        #[inline(always)]
6572        fn inline_size(_context: fidl::encoding::Context) -> usize {
6573            4
6574        }
6575        #[inline(always)]
6576        fn encode_is_copy() -> bool {
6577            true
6578        }
6579
6580        #[inline(always)]
6581        fn decode_is_copy() -> bool {
6582            true
6583        }
6584    }
6585
6586    unsafe impl<D: fidl::encoding::ResourceDialect>
6587        fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D>
6588        for &AudioCapturerStartAsyncCaptureRequest
6589    {
6590        #[inline]
6591        unsafe fn encode(
6592            self,
6593            encoder: &mut fidl::encoding::Encoder<'_, D>,
6594            offset: usize,
6595            _depth: fidl::encoding::Depth,
6596        ) -> fidl::Result<()> {
6597            encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6598            unsafe {
6599                // Copy the object into the buffer.
6600                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6601                (buf_ptr as *mut AudioCapturerStartAsyncCaptureRequest)
6602                    .write_unaligned((self as *const AudioCapturerStartAsyncCaptureRequest).read());
6603                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6604                // done second because the memcpy will write garbage to these bytes.
6605            }
6606            Ok(())
6607        }
6608    }
6609    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
6610        fidl::encoding::Encode<AudioCapturerStartAsyncCaptureRequest, D> for (T0,)
6611    {
6612        #[inline]
6613        unsafe fn encode(
6614            self,
6615            encoder: &mut fidl::encoding::Encoder<'_, D>,
6616            offset: usize,
6617            depth: fidl::encoding::Depth,
6618        ) -> fidl::Result<()> {
6619            encoder.debug_check_bounds::<AudioCapturerStartAsyncCaptureRequest>(offset);
6620            // Zero out padding regions. There's no need to apply masks
6621            // because the unmasked parts will be overwritten by fields.
6622            // Write the fields.
6623            self.0.encode(encoder, offset + 0, depth)?;
6624            Ok(())
6625        }
6626    }
6627
6628    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6629        for AudioCapturerStartAsyncCaptureRequest
6630    {
6631        #[inline(always)]
6632        fn new_empty() -> Self {
6633            Self { frames_per_packet: fidl::new_empty!(u32, D) }
6634        }
6635
6636        #[inline]
6637        unsafe fn decode(
6638            &mut self,
6639            decoder: &mut fidl::encoding::Decoder<'_, D>,
6640            offset: usize,
6641            _depth: fidl::encoding::Depth,
6642        ) -> fidl::Result<()> {
6643            decoder.debug_check_bounds::<Self>(offset);
6644            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6645            // Verify that padding bytes are zero.
6646            // Copy from the buffer into the object.
6647            unsafe {
6648                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
6649            }
6650            Ok(())
6651        }
6652    }
6653
6654    impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatAac {
6655        type Borrowed<'a> = &'a Self;
6656        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6657            value
6658        }
6659    }
6660
6661    unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatAac {
6662        type Owned = Self;
6663
6664        #[inline(always)]
6665        fn inline_align(_context: fidl::encoding::Context) -> usize {
6666            1
6667        }
6668
6669        #[inline(always)]
6670        fn inline_size(_context: fidl::encoding::Context) -> usize {
6671            1
6672        }
6673    }
6674
6675    unsafe impl<D: fidl::encoding::ResourceDialect>
6676        fidl::encoding::Encode<AudioCompressedFormatAac, D> for &AudioCompressedFormatAac
6677    {
6678        #[inline]
6679        unsafe fn encode(
6680            self,
6681            encoder: &mut fidl::encoding::Encoder<'_, D>,
6682            offset: usize,
6683            _depth: fidl::encoding::Depth,
6684        ) -> fidl::Result<()> {
6685            encoder.debug_check_bounds::<AudioCompressedFormatAac>(offset);
6686            encoder.write_num(0u8, offset);
6687            Ok(())
6688        }
6689    }
6690
6691    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6692        for AudioCompressedFormatAac
6693    {
6694        #[inline(always)]
6695        fn new_empty() -> Self {
6696            Self
6697        }
6698
6699        #[inline]
6700        unsafe fn decode(
6701            &mut self,
6702            decoder: &mut fidl::encoding::Decoder<'_, D>,
6703            offset: usize,
6704            _depth: fidl::encoding::Depth,
6705        ) -> fidl::Result<()> {
6706            decoder.debug_check_bounds::<Self>(offset);
6707            match decoder.read_num::<u8>(offset) {
6708                0 => Ok(()),
6709                _ => Err(fidl::Error::Invalid),
6710            }
6711        }
6712    }
6713
6714    impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatSbc {
6715        type Borrowed<'a> = &'a Self;
6716        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6717            value
6718        }
6719    }
6720
6721    unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatSbc {
6722        type Owned = Self;
6723
6724        #[inline(always)]
6725        fn inline_align(_context: fidl::encoding::Context) -> usize {
6726            1
6727        }
6728
6729        #[inline(always)]
6730        fn inline_size(_context: fidl::encoding::Context) -> usize {
6731            1
6732        }
6733    }
6734
6735    unsafe impl<D: fidl::encoding::ResourceDialect>
6736        fidl::encoding::Encode<AudioCompressedFormatSbc, D> for &AudioCompressedFormatSbc
6737    {
6738        #[inline]
6739        unsafe fn encode(
6740            self,
6741            encoder: &mut fidl::encoding::Encoder<'_, D>,
6742            offset: usize,
6743            _depth: fidl::encoding::Depth,
6744        ) -> fidl::Result<()> {
6745            encoder.debug_check_bounds::<AudioCompressedFormatSbc>(offset);
6746            encoder.write_num(0u8, offset);
6747            Ok(())
6748        }
6749    }
6750
6751    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6752        for AudioCompressedFormatSbc
6753    {
6754        #[inline(always)]
6755        fn new_empty() -> Self {
6756            Self
6757        }
6758
6759        #[inline]
6760        unsafe fn decode(
6761            &mut self,
6762            decoder: &mut fidl::encoding::Decoder<'_, D>,
6763            offset: usize,
6764            _depth: fidl::encoding::Depth,
6765        ) -> fidl::Result<()> {
6766            decoder.debug_check_bounds::<Self>(offset);
6767            match decoder.read_num::<u8>(offset) {
6768                0 => Ok(()),
6769                _ => Err(fidl::Error::Invalid),
6770            }
6771        }
6772    }
6773
6774    impl fidl::encoding::ValueTypeMarker for AudioConsumerSetRateRequest {
6775        type Borrowed<'a> = &'a Self;
6776        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6777            value
6778        }
6779    }
6780
6781    unsafe impl fidl::encoding::TypeMarker for AudioConsumerSetRateRequest {
6782        type Owned = Self;
6783
6784        #[inline(always)]
6785        fn inline_align(_context: fidl::encoding::Context) -> usize {
6786            4
6787        }
6788
6789        #[inline(always)]
6790        fn inline_size(_context: fidl::encoding::Context) -> usize {
6791            4
6792        }
6793    }
6794
6795    unsafe impl<D: fidl::encoding::ResourceDialect>
6796        fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for &AudioConsumerSetRateRequest
6797    {
6798        #[inline]
6799        unsafe fn encode(
6800            self,
6801            encoder: &mut fidl::encoding::Encoder<'_, D>,
6802            offset: usize,
6803            _depth: fidl::encoding::Depth,
6804        ) -> fidl::Result<()> {
6805            encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6806            // Delegate to tuple encoding.
6807            fidl::encoding::Encode::<AudioConsumerSetRateRequest, D>::encode(
6808                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.rate),),
6809                encoder,
6810                offset,
6811                _depth,
6812            )
6813        }
6814    }
6815    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
6816        fidl::encoding::Encode<AudioConsumerSetRateRequest, D> for (T0,)
6817    {
6818        #[inline]
6819        unsafe fn encode(
6820            self,
6821            encoder: &mut fidl::encoding::Encoder<'_, D>,
6822            offset: usize,
6823            depth: fidl::encoding::Depth,
6824        ) -> fidl::Result<()> {
6825            encoder.debug_check_bounds::<AudioConsumerSetRateRequest>(offset);
6826            // Zero out padding regions. There's no need to apply masks
6827            // because the unmasked parts will be overwritten by fields.
6828            // Write the fields.
6829            self.0.encode(encoder, offset + 0, depth)?;
6830            Ok(())
6831        }
6832    }
6833
6834    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6835        for AudioConsumerSetRateRequest
6836    {
6837        #[inline(always)]
6838        fn new_empty() -> Self {
6839            Self { rate: fidl::new_empty!(f32, D) }
6840        }
6841
6842        #[inline]
6843        unsafe fn decode(
6844            &mut self,
6845            decoder: &mut fidl::encoding::Decoder<'_, D>,
6846            offset: usize,
6847            _depth: fidl::encoding::Depth,
6848        ) -> fidl::Result<()> {
6849            decoder.debug_check_bounds::<Self>(offset);
6850            // Verify that padding bytes are zero.
6851            fidl::decode!(f32, D, &mut self.rate, decoder, offset + 0, _depth)?;
6852            Ok(())
6853        }
6854    }
6855
6856    impl fidl::encoding::ValueTypeMarker for AudioConsumerStartRequest {
6857        type Borrowed<'a> = &'a Self;
6858        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6859            value
6860        }
6861    }
6862
6863    unsafe impl fidl::encoding::TypeMarker for AudioConsumerStartRequest {
6864        type Owned = Self;
6865
6866        #[inline(always)]
6867        fn inline_align(_context: fidl::encoding::Context) -> usize {
6868            8
6869        }
6870
6871        #[inline(always)]
6872        fn inline_size(_context: fidl::encoding::Context) -> usize {
6873            24
6874        }
6875    }
6876
6877    unsafe impl<D: fidl::encoding::ResourceDialect>
6878        fidl::encoding::Encode<AudioConsumerStartRequest, D> for &AudioConsumerStartRequest
6879    {
6880        #[inline]
6881        unsafe fn encode(
6882            self,
6883            encoder: &mut fidl::encoding::Encoder<'_, D>,
6884            offset: usize,
6885            _depth: fidl::encoding::Depth,
6886        ) -> fidl::Result<()> {
6887            encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6888            // Delegate to tuple encoding.
6889            fidl::encoding::Encode::<AudioConsumerStartRequest, D>::encode(
6890                (
6891                    <AudioConsumerStartFlags as fidl::encoding::ValueTypeMarker>::borrow(
6892                        &self.flags,
6893                    ),
6894                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.reference_time),
6895                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.media_time),
6896                ),
6897                encoder,
6898                offset,
6899                _depth,
6900            )
6901        }
6902    }
6903    unsafe impl<
6904            D: fidl::encoding::ResourceDialect,
6905            T0: fidl::encoding::Encode<AudioConsumerStartFlags, D>,
6906            T1: fidl::encoding::Encode<i64, D>,
6907            T2: fidl::encoding::Encode<i64, D>,
6908        > fidl::encoding::Encode<AudioConsumerStartRequest, D> for (T0, T1, T2)
6909    {
6910        #[inline]
6911        unsafe fn encode(
6912            self,
6913            encoder: &mut fidl::encoding::Encoder<'_, D>,
6914            offset: usize,
6915            depth: fidl::encoding::Depth,
6916        ) -> fidl::Result<()> {
6917            encoder.debug_check_bounds::<AudioConsumerStartRequest>(offset);
6918            // Zero out padding regions. There's no need to apply masks
6919            // because the unmasked parts will be overwritten by fields.
6920            unsafe {
6921                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6922                (ptr as *mut u64).write_unaligned(0);
6923            }
6924            // Write the fields.
6925            self.0.encode(encoder, offset + 0, depth)?;
6926            self.1.encode(encoder, offset + 8, depth)?;
6927            self.2.encode(encoder, offset + 16, depth)?;
6928            Ok(())
6929        }
6930    }
6931
6932    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6933        for AudioConsumerStartRequest
6934    {
6935        #[inline(always)]
6936        fn new_empty() -> Self {
6937            Self {
6938                flags: fidl::new_empty!(AudioConsumerStartFlags, D),
6939                reference_time: fidl::new_empty!(i64, D),
6940                media_time: fidl::new_empty!(i64, D),
6941            }
6942        }
6943
6944        #[inline]
6945        unsafe fn decode(
6946            &mut self,
6947            decoder: &mut fidl::encoding::Decoder<'_, D>,
6948            offset: usize,
6949            _depth: fidl::encoding::Depth,
6950        ) -> fidl::Result<()> {
6951            decoder.debug_check_bounds::<Self>(offset);
6952            // Verify that padding bytes are zero.
6953            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
6954            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6955            let mask = 0xffffffff00000000u64;
6956            let maskedval = padval & mask;
6957            if maskedval != 0 {
6958                return Err(fidl::Error::NonZeroPadding {
6959                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
6960                });
6961            }
6962            fidl::decode!(
6963                AudioConsumerStartFlags,
6964                D,
6965                &mut self.flags,
6966                decoder,
6967                offset + 0,
6968                _depth
6969            )?;
6970            fidl::decode!(i64, D, &mut self.reference_time, decoder, offset + 8, _depth)?;
6971            fidl::decode!(i64, D, &mut self.media_time, decoder, offset + 16, _depth)?;
6972            Ok(())
6973        }
6974    }
6975
6976    impl fidl::encoding::ValueTypeMarker for AudioConsumerWatchStatusResponse {
6977        type Borrowed<'a> = &'a Self;
6978        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6979            value
6980        }
6981    }
6982
6983    unsafe impl fidl::encoding::TypeMarker for AudioConsumerWatchStatusResponse {
6984        type Owned = Self;
6985
6986        #[inline(always)]
6987        fn inline_align(_context: fidl::encoding::Context) -> usize {
6988            8
6989        }
6990
6991        #[inline(always)]
6992        fn inline_size(_context: fidl::encoding::Context) -> usize {
6993            16
6994        }
6995    }
6996
6997    unsafe impl<D: fidl::encoding::ResourceDialect>
6998        fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D>
6999        for &AudioConsumerWatchStatusResponse
7000    {
7001        #[inline]
7002        unsafe fn encode(
7003            self,
7004            encoder: &mut fidl::encoding::Encoder<'_, D>,
7005            offset: usize,
7006            _depth: fidl::encoding::Depth,
7007        ) -> fidl::Result<()> {
7008            encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
7009            // Delegate to tuple encoding.
7010            fidl::encoding::Encode::<AudioConsumerWatchStatusResponse, D>::encode(
7011                (<AudioConsumerStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
7012                encoder,
7013                offset,
7014                _depth,
7015            )
7016        }
7017    }
7018    unsafe impl<
7019            D: fidl::encoding::ResourceDialect,
7020            T0: fidl::encoding::Encode<AudioConsumerStatus, D>,
7021        > fidl::encoding::Encode<AudioConsumerWatchStatusResponse, D> for (T0,)
7022    {
7023        #[inline]
7024        unsafe fn encode(
7025            self,
7026            encoder: &mut fidl::encoding::Encoder<'_, D>,
7027            offset: usize,
7028            depth: fidl::encoding::Depth,
7029        ) -> fidl::Result<()> {
7030            encoder.debug_check_bounds::<AudioConsumerWatchStatusResponse>(offset);
7031            // Zero out padding regions. There's no need to apply masks
7032            // because the unmasked parts will be overwritten by fields.
7033            // Write the fields.
7034            self.0.encode(encoder, offset + 0, depth)?;
7035            Ok(())
7036        }
7037    }
7038
7039    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7040        for AudioConsumerWatchStatusResponse
7041    {
7042        #[inline(always)]
7043        fn new_empty() -> Self {
7044            Self { status: fidl::new_empty!(AudioConsumerStatus, D) }
7045        }
7046
7047        #[inline]
7048        unsafe fn decode(
7049            &mut self,
7050            decoder: &mut fidl::encoding::Decoder<'_, D>,
7051            offset: usize,
7052            _depth: fidl::encoding::Depth,
7053        ) -> fidl::Result<()> {
7054            decoder.debug_check_bounds::<Self>(offset);
7055            // Verify that padding bytes are zero.
7056            fidl::decode!(AudioConsumerStatus, D, &mut self.status, decoder, offset + 0, _depth)?;
7057            Ok(())
7058        }
7059    }
7060
7061    impl fidl::encoding::ValueTypeMarker for AudioCoreEnableDeviceSettingsRequest {
7062        type Borrowed<'a> = &'a Self;
7063        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7064            value
7065        }
7066    }
7067
7068    unsafe impl fidl::encoding::TypeMarker for AudioCoreEnableDeviceSettingsRequest {
7069        type Owned = Self;
7070
7071        #[inline(always)]
7072        fn inline_align(_context: fidl::encoding::Context) -> usize {
7073            1
7074        }
7075
7076        #[inline(always)]
7077        fn inline_size(_context: fidl::encoding::Context) -> usize {
7078            1
7079        }
7080    }
7081
7082    unsafe impl<D: fidl::encoding::ResourceDialect>
7083        fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D>
7084        for &AudioCoreEnableDeviceSettingsRequest
7085    {
7086        #[inline]
7087        unsafe fn encode(
7088            self,
7089            encoder: &mut fidl::encoding::Encoder<'_, D>,
7090            offset: usize,
7091            _depth: fidl::encoding::Depth,
7092        ) -> fidl::Result<()> {
7093            encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
7094            // Delegate to tuple encoding.
7095            fidl::encoding::Encode::<AudioCoreEnableDeviceSettingsRequest, D>::encode(
7096                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
7097                encoder,
7098                offset,
7099                _depth,
7100            )
7101        }
7102    }
7103    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
7104        fidl::encoding::Encode<AudioCoreEnableDeviceSettingsRequest, D> for (T0,)
7105    {
7106        #[inline]
7107        unsafe fn encode(
7108            self,
7109            encoder: &mut fidl::encoding::Encoder<'_, D>,
7110            offset: usize,
7111            depth: fidl::encoding::Depth,
7112        ) -> fidl::Result<()> {
7113            encoder.debug_check_bounds::<AudioCoreEnableDeviceSettingsRequest>(offset);
7114            // Zero out padding regions. There's no need to apply masks
7115            // because the unmasked parts will be overwritten by fields.
7116            // Write the fields.
7117            self.0.encode(encoder, offset + 0, depth)?;
7118            Ok(())
7119        }
7120    }
7121
7122    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7123        for AudioCoreEnableDeviceSettingsRequest
7124    {
7125        #[inline(always)]
7126        fn new_empty() -> Self {
7127            Self { enabled: fidl::new_empty!(bool, D) }
7128        }
7129
7130        #[inline]
7131        unsafe fn decode(
7132            &mut self,
7133            decoder: &mut fidl::encoding::Decoder<'_, D>,
7134            offset: usize,
7135            _depth: fidl::encoding::Depth,
7136        ) -> fidl::Result<()> {
7137            decoder.debug_check_bounds::<Self>(offset);
7138            // Verify that padding bytes are zero.
7139            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
7140            Ok(())
7141        }
7142    }
7143
7144    impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Request {
7145        type Borrowed<'a> = &'a Self;
7146        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7147            value
7148        }
7149    }
7150
7151    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Request {
7152        type Owned = Self;
7153
7154        #[inline(always)]
7155        fn inline_align(_context: fidl::encoding::Context) -> usize {
7156            8
7157        }
7158
7159        #[inline(always)]
7160        fn inline_size(_context: fidl::encoding::Context) -> usize {
7161            24
7162        }
7163    }
7164
7165    unsafe impl<D: fidl::encoding::ResourceDialect>
7166        fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D>
7167        for &AudioCoreGetDbFromVolume2Request
7168    {
7169        #[inline]
7170        unsafe fn encode(
7171            self,
7172            encoder: &mut fidl::encoding::Encoder<'_, D>,
7173            offset: usize,
7174            _depth: fidl::encoding::Depth,
7175        ) -> fidl::Result<()> {
7176            encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
7177            // Delegate to tuple encoding.
7178            fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Request, D>::encode(
7179                (
7180                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7181                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
7182                ),
7183                encoder,
7184                offset,
7185                _depth,
7186            )
7187        }
7188    }
7189    unsafe impl<
7190            D: fidl::encoding::ResourceDialect,
7191            T0: fidl::encoding::Encode<Usage2, D>,
7192            T1: fidl::encoding::Encode<f32, D>,
7193        > fidl::encoding::Encode<AudioCoreGetDbFromVolume2Request, D> for (T0, T1)
7194    {
7195        #[inline]
7196        unsafe fn encode(
7197            self,
7198            encoder: &mut fidl::encoding::Encoder<'_, D>,
7199            offset: usize,
7200            depth: fidl::encoding::Depth,
7201        ) -> fidl::Result<()> {
7202            encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Request>(offset);
7203            // Zero out padding regions. There's no need to apply masks
7204            // because the unmasked parts will be overwritten by fields.
7205            unsafe {
7206                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7207                (ptr as *mut u64).write_unaligned(0);
7208            }
7209            // Write the fields.
7210            self.0.encode(encoder, offset + 0, depth)?;
7211            self.1.encode(encoder, offset + 16, depth)?;
7212            Ok(())
7213        }
7214    }
7215
7216    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7217        for AudioCoreGetDbFromVolume2Request
7218    {
7219        #[inline(always)]
7220        fn new_empty() -> Self {
7221            Self { usage: fidl::new_empty!(Usage2, D), volume: fidl::new_empty!(f32, D) }
7222        }
7223
7224        #[inline]
7225        unsafe fn decode(
7226            &mut self,
7227            decoder: &mut fidl::encoding::Decoder<'_, D>,
7228            offset: usize,
7229            _depth: fidl::encoding::Depth,
7230        ) -> fidl::Result<()> {
7231            decoder.debug_check_bounds::<Self>(offset);
7232            // Verify that padding bytes are zero.
7233            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7234            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7235            let mask = 0xffffffff00000000u64;
7236            let maskedval = padval & mask;
7237            if maskedval != 0 {
7238                return Err(fidl::Error::NonZeroPadding {
7239                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7240                });
7241            }
7242            fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7243            fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7244            Ok(())
7245        }
7246    }
7247
7248    impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeRequest {
7249        type Borrowed<'a> = &'a Self;
7250        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7251            value
7252        }
7253    }
7254
7255    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeRequest {
7256        type Owned = Self;
7257
7258        #[inline(always)]
7259        fn inline_align(_context: fidl::encoding::Context) -> usize {
7260            8
7261        }
7262
7263        #[inline(always)]
7264        fn inline_size(_context: fidl::encoding::Context) -> usize {
7265            24
7266        }
7267    }
7268
7269    unsafe impl<D: fidl::encoding::ResourceDialect>
7270        fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D>
7271        for &AudioCoreGetDbFromVolumeRequest
7272    {
7273        #[inline]
7274        unsafe fn encode(
7275            self,
7276            encoder: &mut fidl::encoding::Encoder<'_, D>,
7277            offset: usize,
7278            _depth: fidl::encoding::Depth,
7279        ) -> fidl::Result<()> {
7280            encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeRequest>(offset);
7281            // Delegate to tuple encoding.
7282            fidl::encoding::Encode::<AudioCoreGetDbFromVolumeRequest, D>::encode(
7283                (
7284                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7285                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),
7286                ),
7287                encoder,
7288                offset,
7289                _depth,
7290            )
7291        }
7292    }
7293    unsafe impl<
7294            D: fidl::encoding::ResourceDialect,
7295            T0: fidl::encoding::Encode<Usage, D>,
7296            T1: fidl::encoding::Encode<f32, D>,
7297        > fidl::encoding::Encode<AudioCoreGetDbFromVolumeRequest, D> for (T0, T1)
7298    {
7299        #[inline]
7300        unsafe fn encode(
7301            self,
7302            encoder: &mut fidl::encoding::Encoder<'_, D>,
7303            offset: usize,
7304            depth: fidl::encoding::Depth,
7305        ) -> fidl::Result<()> {
7306            encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeRequest>(offset);
7307            // Zero out padding regions. There's no need to apply masks
7308            // because the unmasked parts will be overwritten by fields.
7309            unsafe {
7310                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7311                (ptr as *mut u64).write_unaligned(0);
7312            }
7313            // Write the fields.
7314            self.0.encode(encoder, offset + 0, depth)?;
7315            self.1.encode(encoder, offset + 16, depth)?;
7316            Ok(())
7317        }
7318    }
7319
7320    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7321        for AudioCoreGetDbFromVolumeRequest
7322    {
7323        #[inline(always)]
7324        fn new_empty() -> Self {
7325            Self { usage: fidl::new_empty!(Usage, D), volume: fidl::new_empty!(f32, D) }
7326        }
7327
7328        #[inline]
7329        unsafe fn decode(
7330            &mut self,
7331            decoder: &mut fidl::encoding::Decoder<'_, D>,
7332            offset: usize,
7333            _depth: fidl::encoding::Depth,
7334        ) -> fidl::Result<()> {
7335            decoder.debug_check_bounds::<Self>(offset);
7336            // Verify that padding bytes are zero.
7337            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7338            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7339            let mask = 0xffffffff00000000u64;
7340            let maskedval = padval & mask;
7341            if maskedval != 0 {
7342                return Err(fidl::Error::NonZeroPadding {
7343                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7344                });
7345            }
7346            fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7347            fidl::decode!(f32, D, &mut self.volume, decoder, offset + 16, _depth)?;
7348            Ok(())
7349        }
7350    }
7351
7352    impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolumeResponse {
7353        type Borrowed<'a> = &'a Self;
7354        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7355            value
7356        }
7357    }
7358
7359    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolumeResponse {
7360        type Owned = Self;
7361
7362        #[inline(always)]
7363        fn inline_align(_context: fidl::encoding::Context) -> usize {
7364            4
7365        }
7366
7367        #[inline(always)]
7368        fn inline_size(_context: fidl::encoding::Context) -> usize {
7369            4
7370        }
7371    }
7372
7373    unsafe impl<D: fidl::encoding::ResourceDialect>
7374        fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D>
7375        for &AudioCoreGetDbFromVolumeResponse
7376    {
7377        #[inline]
7378        unsafe fn encode(
7379            self,
7380            encoder: &mut fidl::encoding::Encoder<'_, D>,
7381            offset: usize,
7382            _depth: fidl::encoding::Depth,
7383        ) -> fidl::Result<()> {
7384            encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7385            // Delegate to tuple encoding.
7386            fidl::encoding::Encode::<AudioCoreGetDbFromVolumeResponse, D>::encode(
7387                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
7388                encoder,
7389                offset,
7390                _depth,
7391            )
7392        }
7393    }
7394    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7395        fidl::encoding::Encode<AudioCoreGetDbFromVolumeResponse, D> for (T0,)
7396    {
7397        #[inline]
7398        unsafe fn encode(
7399            self,
7400            encoder: &mut fidl::encoding::Encoder<'_, D>,
7401            offset: usize,
7402            depth: fidl::encoding::Depth,
7403        ) -> fidl::Result<()> {
7404            encoder.debug_check_bounds::<AudioCoreGetDbFromVolumeResponse>(offset);
7405            // Zero out padding regions. There's no need to apply masks
7406            // because the unmasked parts will be overwritten by fields.
7407            // Write the fields.
7408            self.0.encode(encoder, offset + 0, depth)?;
7409            Ok(())
7410        }
7411    }
7412
7413    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7414        for AudioCoreGetDbFromVolumeResponse
7415    {
7416        #[inline(always)]
7417        fn new_empty() -> Self {
7418            Self { gain_db: fidl::new_empty!(f32, D) }
7419        }
7420
7421        #[inline]
7422        unsafe fn decode(
7423            &mut self,
7424            decoder: &mut fidl::encoding::Decoder<'_, D>,
7425            offset: usize,
7426            _depth: fidl::encoding::Depth,
7427        ) -> fidl::Result<()> {
7428            decoder.debug_check_bounds::<Self>(offset);
7429            // Verify that padding bytes are zero.
7430            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
7431            Ok(())
7432        }
7433    }
7434
7435    impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Request {
7436        type Borrowed<'a> = &'a Self;
7437        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7438            value
7439        }
7440    }
7441
7442    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Request {
7443        type Owned = Self;
7444
7445        #[inline(always)]
7446        fn inline_align(_context: fidl::encoding::Context) -> usize {
7447            8
7448        }
7449
7450        #[inline(always)]
7451        fn inline_size(_context: fidl::encoding::Context) -> usize {
7452            24
7453        }
7454    }
7455
7456    unsafe impl<D: fidl::encoding::ResourceDialect>
7457        fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D>
7458        for &AudioCoreGetVolumeFromDb2Request
7459    {
7460        #[inline]
7461        unsafe fn encode(
7462            self,
7463            encoder: &mut fidl::encoding::Encoder<'_, D>,
7464            offset: usize,
7465            _depth: fidl::encoding::Depth,
7466        ) -> fidl::Result<()> {
7467            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7468            // Delegate to tuple encoding.
7469            fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Request, D>::encode(
7470                (
7471                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7472                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7473                ),
7474                encoder,
7475                offset,
7476                _depth,
7477            )
7478        }
7479    }
7480    unsafe impl<
7481            D: fidl::encoding::ResourceDialect,
7482            T0: fidl::encoding::Encode<Usage2, D>,
7483            T1: fidl::encoding::Encode<f32, D>,
7484        > fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Request, D> for (T0, T1)
7485    {
7486        #[inline]
7487        unsafe fn encode(
7488            self,
7489            encoder: &mut fidl::encoding::Encoder<'_, D>,
7490            offset: usize,
7491            depth: fidl::encoding::Depth,
7492        ) -> fidl::Result<()> {
7493            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Request>(offset);
7494            // Zero out padding regions. There's no need to apply masks
7495            // because the unmasked parts will be overwritten by fields.
7496            unsafe {
7497                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7498                (ptr as *mut u64).write_unaligned(0);
7499            }
7500            // Write the fields.
7501            self.0.encode(encoder, offset + 0, depth)?;
7502            self.1.encode(encoder, offset + 16, depth)?;
7503            Ok(())
7504        }
7505    }
7506
7507    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7508        for AudioCoreGetVolumeFromDb2Request
7509    {
7510        #[inline(always)]
7511        fn new_empty() -> Self {
7512            Self { usage: fidl::new_empty!(Usage2, D), gain_db: fidl::new_empty!(f32, D) }
7513        }
7514
7515        #[inline]
7516        unsafe fn decode(
7517            &mut self,
7518            decoder: &mut fidl::encoding::Decoder<'_, D>,
7519            offset: usize,
7520            _depth: fidl::encoding::Depth,
7521        ) -> fidl::Result<()> {
7522            decoder.debug_check_bounds::<Self>(offset);
7523            // Verify that padding bytes are zero.
7524            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7525            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7526            let mask = 0xffffffff00000000u64;
7527            let maskedval = padval & mask;
7528            if maskedval != 0 {
7529                return Err(fidl::Error::NonZeroPadding {
7530                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7531                });
7532            }
7533            fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7534            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7535            Ok(())
7536        }
7537    }
7538
7539    impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbRequest {
7540        type Borrowed<'a> = &'a Self;
7541        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7542            value
7543        }
7544    }
7545
7546    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbRequest {
7547        type Owned = Self;
7548
7549        #[inline(always)]
7550        fn inline_align(_context: fidl::encoding::Context) -> usize {
7551            8
7552        }
7553
7554        #[inline(always)]
7555        fn inline_size(_context: fidl::encoding::Context) -> usize {
7556            24
7557        }
7558    }
7559
7560    unsafe impl<D: fidl::encoding::ResourceDialect>
7561        fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D>
7562        for &AudioCoreGetVolumeFromDbRequest
7563    {
7564        #[inline]
7565        unsafe fn encode(
7566            self,
7567            encoder: &mut fidl::encoding::Encoder<'_, D>,
7568            offset: usize,
7569            _depth: fidl::encoding::Depth,
7570        ) -> fidl::Result<()> {
7571            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbRequest>(offset);
7572            // Delegate to tuple encoding.
7573            fidl::encoding::Encode::<AudioCoreGetVolumeFromDbRequest, D>::encode(
7574                (
7575                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7576                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7577                ),
7578                encoder,
7579                offset,
7580                _depth,
7581            )
7582        }
7583    }
7584    unsafe impl<
7585            D: fidl::encoding::ResourceDialect,
7586            T0: fidl::encoding::Encode<Usage, D>,
7587            T1: fidl::encoding::Encode<f32, D>,
7588        > fidl::encoding::Encode<AudioCoreGetVolumeFromDbRequest, D> for (T0, T1)
7589    {
7590        #[inline]
7591        unsafe fn encode(
7592            self,
7593            encoder: &mut fidl::encoding::Encoder<'_, D>,
7594            offset: usize,
7595            depth: fidl::encoding::Depth,
7596        ) -> fidl::Result<()> {
7597            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbRequest>(offset);
7598            // Zero out padding regions. There's no need to apply masks
7599            // because the unmasked parts will be overwritten by fields.
7600            unsafe {
7601                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7602                (ptr as *mut u64).write_unaligned(0);
7603            }
7604            // Write the fields.
7605            self.0.encode(encoder, offset + 0, depth)?;
7606            self.1.encode(encoder, offset + 16, depth)?;
7607            Ok(())
7608        }
7609    }
7610
7611    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7612        for AudioCoreGetVolumeFromDbRequest
7613    {
7614        #[inline(always)]
7615        fn new_empty() -> Self {
7616            Self { usage: fidl::new_empty!(Usage, D), gain_db: fidl::new_empty!(f32, D) }
7617        }
7618
7619        #[inline]
7620        unsafe fn decode(
7621            &mut self,
7622            decoder: &mut fidl::encoding::Decoder<'_, D>,
7623            offset: usize,
7624            _depth: fidl::encoding::Depth,
7625        ) -> fidl::Result<()> {
7626            decoder.debug_check_bounds::<Self>(offset);
7627            // Verify that padding bytes are zero.
7628            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7629            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7630            let mask = 0xffffffff00000000u64;
7631            let maskedval = padval & mask;
7632            if maskedval != 0 {
7633                return Err(fidl::Error::NonZeroPadding {
7634                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7635                });
7636            }
7637            fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7638            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 16, _depth)?;
7639            Ok(())
7640        }
7641    }
7642
7643    impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDbResponse {
7644        type Borrowed<'a> = &'a Self;
7645        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7646            value
7647        }
7648    }
7649
7650    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDbResponse {
7651        type Owned = Self;
7652
7653        #[inline(always)]
7654        fn inline_align(_context: fidl::encoding::Context) -> usize {
7655            4
7656        }
7657
7658        #[inline(always)]
7659        fn inline_size(_context: fidl::encoding::Context) -> usize {
7660            4
7661        }
7662    }
7663
7664    unsafe impl<D: fidl::encoding::ResourceDialect>
7665        fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D>
7666        for &AudioCoreGetVolumeFromDbResponse
7667    {
7668        #[inline]
7669        unsafe fn encode(
7670            self,
7671            encoder: &mut fidl::encoding::Encoder<'_, D>,
7672            offset: usize,
7673            _depth: fidl::encoding::Depth,
7674        ) -> fidl::Result<()> {
7675            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7676            // Delegate to tuple encoding.
7677            fidl::encoding::Encode::<AudioCoreGetVolumeFromDbResponse, D>::encode(
7678                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
7679                encoder,
7680                offset,
7681                _depth,
7682            )
7683        }
7684    }
7685    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
7686        fidl::encoding::Encode<AudioCoreGetVolumeFromDbResponse, D> for (T0,)
7687    {
7688        #[inline]
7689        unsafe fn encode(
7690            self,
7691            encoder: &mut fidl::encoding::Encoder<'_, D>,
7692            offset: usize,
7693            depth: fidl::encoding::Depth,
7694        ) -> fidl::Result<()> {
7695            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDbResponse>(offset);
7696            // Zero out padding regions. There's no need to apply masks
7697            // because the unmasked parts will be overwritten by fields.
7698            // Write the fields.
7699            self.0.encode(encoder, offset + 0, depth)?;
7700            Ok(())
7701        }
7702    }
7703
7704    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7705        for AudioCoreGetVolumeFromDbResponse
7706    {
7707        #[inline(always)]
7708        fn new_empty() -> Self {
7709            Self { volume: fidl::new_empty!(f32, D) }
7710        }
7711
7712        #[inline]
7713        unsafe fn decode(
7714            &mut self,
7715            decoder: &mut fidl::encoding::Decoder<'_, D>,
7716            offset: usize,
7717            _depth: fidl::encoding::Depth,
7718        ) -> fidl::Result<()> {
7719            decoder.debug_check_bounds::<Self>(offset);
7720            // Verify that padding bytes are zero.
7721            fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
7722            Ok(())
7723        }
7724    }
7725
7726    impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGain2Request {
7727        type Borrowed<'a> = &'a Self;
7728        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7729            value
7730        }
7731    }
7732
7733    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGain2Request {
7734        type Owned = Self;
7735
7736        #[inline(always)]
7737        fn inline_align(_context: fidl::encoding::Context) -> usize {
7738            4
7739        }
7740
7741        #[inline(always)]
7742        fn inline_size(_context: fidl::encoding::Context) -> usize {
7743            8
7744        }
7745    }
7746
7747    unsafe impl<D: fidl::encoding::ResourceDialect>
7748        fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D>
7749        for &AudioCoreSetCaptureUsageGain2Request
7750    {
7751        #[inline]
7752        unsafe fn encode(
7753            self,
7754            encoder: &mut fidl::encoding::Encoder<'_, D>,
7755            offset: usize,
7756            _depth: fidl::encoding::Depth,
7757        ) -> fidl::Result<()> {
7758            encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7759            // Delegate to tuple encoding.
7760            fidl::encoding::Encode::<AudioCoreSetCaptureUsageGain2Request, D>::encode(
7761                (
7762                    <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7763                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7764                ),
7765                encoder,
7766                offset,
7767                _depth,
7768            )
7769        }
7770    }
7771    unsafe impl<
7772            D: fidl::encoding::ResourceDialect,
7773            T0: fidl::encoding::Encode<AudioCaptureUsage2, D>,
7774            T1: fidl::encoding::Encode<f32, D>,
7775        > fidl::encoding::Encode<AudioCoreSetCaptureUsageGain2Request, D> for (T0, T1)
7776    {
7777        #[inline]
7778        unsafe fn encode(
7779            self,
7780            encoder: &mut fidl::encoding::Encoder<'_, D>,
7781            offset: usize,
7782            depth: fidl::encoding::Depth,
7783        ) -> fidl::Result<()> {
7784            encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGain2Request>(offset);
7785            // Zero out padding regions. There's no need to apply masks
7786            // because the unmasked parts will be overwritten by fields.
7787            // Write the fields.
7788            self.0.encode(encoder, offset + 0, depth)?;
7789            self.1.encode(encoder, offset + 4, depth)?;
7790            Ok(())
7791        }
7792    }
7793
7794    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7795        for AudioCoreSetCaptureUsageGain2Request
7796    {
7797        #[inline(always)]
7798        fn new_empty() -> Self {
7799            Self {
7800                usage: fidl::new_empty!(AudioCaptureUsage2, D),
7801                gain_db: fidl::new_empty!(f32, D),
7802            }
7803        }
7804
7805        #[inline]
7806        unsafe fn decode(
7807            &mut self,
7808            decoder: &mut fidl::encoding::Decoder<'_, D>,
7809            offset: usize,
7810            _depth: fidl::encoding::Depth,
7811        ) -> fidl::Result<()> {
7812            decoder.debug_check_bounds::<Self>(offset);
7813            // Verify that padding bytes are zero.
7814            fidl::decode!(AudioCaptureUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
7815            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7816            Ok(())
7817        }
7818    }
7819
7820    impl fidl::encoding::ValueTypeMarker for AudioCoreSetCaptureUsageGainRequest {
7821        type Borrowed<'a> = &'a Self;
7822        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7823            value
7824        }
7825    }
7826
7827    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetCaptureUsageGainRequest {
7828        type Owned = Self;
7829
7830        #[inline(always)]
7831        fn inline_align(_context: fidl::encoding::Context) -> usize {
7832            4
7833        }
7834
7835        #[inline(always)]
7836        fn inline_size(_context: fidl::encoding::Context) -> usize {
7837            8
7838        }
7839    }
7840
7841    unsafe impl<D: fidl::encoding::ResourceDialect>
7842        fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D>
7843        for &AudioCoreSetCaptureUsageGainRequest
7844    {
7845        #[inline]
7846        unsafe fn encode(
7847            self,
7848            encoder: &mut fidl::encoding::Encoder<'_, D>,
7849            offset: usize,
7850            _depth: fidl::encoding::Depth,
7851        ) -> fidl::Result<()> {
7852            encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7853            // Delegate to tuple encoding.
7854            fidl::encoding::Encode::<AudioCoreSetCaptureUsageGainRequest, D>::encode(
7855                (
7856                    <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
7857                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
7858                ),
7859                encoder,
7860                offset,
7861                _depth,
7862            )
7863        }
7864    }
7865    unsafe impl<
7866            D: fidl::encoding::ResourceDialect,
7867            T0: fidl::encoding::Encode<AudioCaptureUsage, D>,
7868            T1: fidl::encoding::Encode<f32, D>,
7869        > fidl::encoding::Encode<AudioCoreSetCaptureUsageGainRequest, D> for (T0, T1)
7870    {
7871        #[inline]
7872        unsafe fn encode(
7873            self,
7874            encoder: &mut fidl::encoding::Encoder<'_, D>,
7875            offset: usize,
7876            depth: fidl::encoding::Depth,
7877        ) -> fidl::Result<()> {
7878            encoder.debug_check_bounds::<AudioCoreSetCaptureUsageGainRequest>(offset);
7879            // Zero out padding regions. There's no need to apply masks
7880            // because the unmasked parts will be overwritten by fields.
7881            // Write the fields.
7882            self.0.encode(encoder, offset + 0, depth)?;
7883            self.1.encode(encoder, offset + 4, depth)?;
7884            Ok(())
7885        }
7886    }
7887
7888    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7889        for AudioCoreSetCaptureUsageGainRequest
7890    {
7891        #[inline(always)]
7892        fn new_empty() -> Self {
7893            Self {
7894                usage: fidl::new_empty!(AudioCaptureUsage, D),
7895                gain_db: fidl::new_empty!(f32, D),
7896            }
7897        }
7898
7899        #[inline]
7900        unsafe fn decode(
7901            &mut self,
7902            decoder: &mut fidl::encoding::Decoder<'_, D>,
7903            offset: usize,
7904            _depth: fidl::encoding::Depth,
7905        ) -> fidl::Result<()> {
7906            decoder.debug_check_bounds::<Self>(offset);
7907            // Verify that padding bytes are zero.
7908            fidl::decode!(AudioCaptureUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
7909            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
7910            Ok(())
7911        }
7912    }
7913
7914    impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteraction2Request {
7915        type Borrowed<'a> = &'a Self;
7916        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7917            value
7918        }
7919    }
7920
7921    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteraction2Request {
7922        type Owned = Self;
7923
7924        #[inline(always)]
7925        fn inline_align(_context: fidl::encoding::Context) -> usize {
7926            8
7927        }
7928
7929        #[inline(always)]
7930        fn inline_size(_context: fidl::encoding::Context) -> usize {
7931            40
7932        }
7933    }
7934
7935    unsafe impl<D: fidl::encoding::ResourceDialect>
7936        fidl::encoding::Encode<AudioCoreSetInteraction2Request, D>
7937        for &AudioCoreSetInteraction2Request
7938    {
7939        #[inline]
7940        unsafe fn encode(
7941            self,
7942            encoder: &mut fidl::encoding::Encoder<'_, D>,
7943            offset: usize,
7944            _depth: fidl::encoding::Depth,
7945        ) -> fidl::Result<()> {
7946            encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7947            // Delegate to tuple encoding.
7948            fidl::encoding::Encode::<AudioCoreSetInteraction2Request, D>::encode(
7949                (
7950                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
7951                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
7952                    <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
7953                ),
7954                encoder,
7955                offset,
7956                _depth,
7957            )
7958        }
7959    }
7960    unsafe impl<
7961            D: fidl::encoding::ResourceDialect,
7962            T0: fidl::encoding::Encode<Usage2, D>,
7963            T1: fidl::encoding::Encode<Usage2, D>,
7964            T2: fidl::encoding::Encode<Behavior, D>,
7965        > fidl::encoding::Encode<AudioCoreSetInteraction2Request, D> for (T0, T1, T2)
7966    {
7967        #[inline]
7968        unsafe fn encode(
7969            self,
7970            encoder: &mut fidl::encoding::Encoder<'_, D>,
7971            offset: usize,
7972            depth: fidl::encoding::Depth,
7973        ) -> fidl::Result<()> {
7974            encoder.debug_check_bounds::<AudioCoreSetInteraction2Request>(offset);
7975            // Zero out padding regions. There's no need to apply masks
7976            // because the unmasked parts will be overwritten by fields.
7977            unsafe {
7978                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
7979                (ptr as *mut u64).write_unaligned(0);
7980            }
7981            // Write the fields.
7982            self.0.encode(encoder, offset + 0, depth)?;
7983            self.1.encode(encoder, offset + 16, depth)?;
7984            self.2.encode(encoder, offset + 32, depth)?;
7985            Ok(())
7986        }
7987    }
7988
7989    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7990        for AudioCoreSetInteraction2Request
7991    {
7992        #[inline(always)]
7993        fn new_empty() -> Self {
7994            Self {
7995                active: fidl::new_empty!(Usage2, D),
7996                affected: fidl::new_empty!(Usage2, D),
7997                behavior: fidl::new_empty!(Behavior, D),
7998            }
7999        }
8000
8001        #[inline]
8002        unsafe fn decode(
8003            &mut self,
8004            decoder: &mut fidl::encoding::Decoder<'_, D>,
8005            offset: usize,
8006            _depth: fidl::encoding::Depth,
8007        ) -> fidl::Result<()> {
8008            decoder.debug_check_bounds::<Self>(offset);
8009            // Verify that padding bytes are zero.
8010            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
8011            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8012            let mask = 0xffffffff00000000u64;
8013            let maskedval = padval & mask;
8014            if maskedval != 0 {
8015                return Err(fidl::Error::NonZeroPadding {
8016                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
8017                });
8018            }
8019            fidl::decode!(Usage2, D, &mut self.active, decoder, offset + 0, _depth)?;
8020            fidl::decode!(Usage2, D, &mut self.affected, decoder, offset + 16, _depth)?;
8021            fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
8022            Ok(())
8023        }
8024    }
8025
8026    impl fidl::encoding::ValueTypeMarker for AudioCoreSetInteractionRequest {
8027        type Borrowed<'a> = &'a Self;
8028        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8029            value
8030        }
8031    }
8032
8033    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetInteractionRequest {
8034        type Owned = Self;
8035
8036        #[inline(always)]
8037        fn inline_align(_context: fidl::encoding::Context) -> usize {
8038            8
8039        }
8040
8041        #[inline(always)]
8042        fn inline_size(_context: fidl::encoding::Context) -> usize {
8043            40
8044        }
8045    }
8046
8047    unsafe impl<D: fidl::encoding::ResourceDialect>
8048        fidl::encoding::Encode<AudioCoreSetInteractionRequest, D>
8049        for &AudioCoreSetInteractionRequest
8050    {
8051        #[inline]
8052        unsafe fn encode(
8053            self,
8054            encoder: &mut fidl::encoding::Encoder<'_, D>,
8055            offset: usize,
8056            _depth: fidl::encoding::Depth,
8057        ) -> fidl::Result<()> {
8058            encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
8059            // Delegate to tuple encoding.
8060            fidl::encoding::Encode::<AudioCoreSetInteractionRequest, D>::encode(
8061                (
8062                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.active),
8063                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.affected),
8064                    <Behavior as fidl::encoding::ValueTypeMarker>::borrow(&self.behavior),
8065                ),
8066                encoder,
8067                offset,
8068                _depth,
8069            )
8070        }
8071    }
8072    unsafe impl<
8073            D: fidl::encoding::ResourceDialect,
8074            T0: fidl::encoding::Encode<Usage, D>,
8075            T1: fidl::encoding::Encode<Usage, D>,
8076            T2: fidl::encoding::Encode<Behavior, D>,
8077        > fidl::encoding::Encode<AudioCoreSetInteractionRequest, D> for (T0, T1, T2)
8078    {
8079        #[inline]
8080        unsafe fn encode(
8081            self,
8082            encoder: &mut fidl::encoding::Encoder<'_, D>,
8083            offset: usize,
8084            depth: fidl::encoding::Depth,
8085        ) -> fidl::Result<()> {
8086            encoder.debug_check_bounds::<AudioCoreSetInteractionRequest>(offset);
8087            // Zero out padding regions. There's no need to apply masks
8088            // because the unmasked parts will be overwritten by fields.
8089            unsafe {
8090                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
8091                (ptr as *mut u64).write_unaligned(0);
8092            }
8093            // Write the fields.
8094            self.0.encode(encoder, offset + 0, depth)?;
8095            self.1.encode(encoder, offset + 16, depth)?;
8096            self.2.encode(encoder, offset + 32, depth)?;
8097            Ok(())
8098        }
8099    }
8100
8101    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8102        for AudioCoreSetInteractionRequest
8103    {
8104        #[inline(always)]
8105        fn new_empty() -> Self {
8106            Self {
8107                active: fidl::new_empty!(Usage, D),
8108                affected: fidl::new_empty!(Usage, D),
8109                behavior: fidl::new_empty!(Behavior, D),
8110            }
8111        }
8112
8113        #[inline]
8114        unsafe fn decode(
8115            &mut self,
8116            decoder: &mut fidl::encoding::Decoder<'_, D>,
8117            offset: usize,
8118            _depth: fidl::encoding::Depth,
8119        ) -> fidl::Result<()> {
8120            decoder.debug_check_bounds::<Self>(offset);
8121            // Verify that padding bytes are zero.
8122            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
8123            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8124            let mask = 0xffffffff00000000u64;
8125            let maskedval = padval & mask;
8126            if maskedval != 0 {
8127                return Err(fidl::Error::NonZeroPadding {
8128                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
8129                });
8130            }
8131            fidl::decode!(Usage, D, &mut self.active, decoder, offset + 0, _depth)?;
8132            fidl::decode!(Usage, D, &mut self.affected, decoder, offset + 16, _depth)?;
8133            fidl::decode!(Behavior, D, &mut self.behavior, decoder, offset + 32, _depth)?;
8134            Ok(())
8135        }
8136    }
8137
8138    impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGain2Request {
8139        type Borrowed<'a> = &'a Self;
8140        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8141            value
8142        }
8143    }
8144
8145    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGain2Request {
8146        type Owned = Self;
8147
8148        #[inline(always)]
8149        fn inline_align(_context: fidl::encoding::Context) -> usize {
8150            4
8151        }
8152
8153        #[inline(always)]
8154        fn inline_size(_context: fidl::encoding::Context) -> usize {
8155            8
8156        }
8157    }
8158
8159    unsafe impl<D: fidl::encoding::ResourceDialect>
8160        fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D>
8161        for &AudioCoreSetRenderUsageGain2Request
8162    {
8163        #[inline]
8164        unsafe fn encode(
8165            self,
8166            encoder: &mut fidl::encoding::Encoder<'_, D>,
8167            offset: usize,
8168            _depth: fidl::encoding::Depth,
8169        ) -> fidl::Result<()> {
8170            encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
8171            // Delegate to tuple encoding.
8172            fidl::encoding::Encode::<AudioCoreSetRenderUsageGain2Request, D>::encode(
8173                (
8174                    <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
8175                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
8176                ),
8177                encoder,
8178                offset,
8179                _depth,
8180            )
8181        }
8182    }
8183    unsafe impl<
8184            D: fidl::encoding::ResourceDialect,
8185            T0: fidl::encoding::Encode<AudioRenderUsage2, D>,
8186            T1: fidl::encoding::Encode<f32, D>,
8187        > fidl::encoding::Encode<AudioCoreSetRenderUsageGain2Request, D> for (T0, T1)
8188    {
8189        #[inline]
8190        unsafe fn encode(
8191            self,
8192            encoder: &mut fidl::encoding::Encoder<'_, D>,
8193            offset: usize,
8194            depth: fidl::encoding::Depth,
8195        ) -> fidl::Result<()> {
8196            encoder.debug_check_bounds::<AudioCoreSetRenderUsageGain2Request>(offset);
8197            // Zero out padding regions. There's no need to apply masks
8198            // because the unmasked parts will be overwritten by fields.
8199            // Write the fields.
8200            self.0.encode(encoder, offset + 0, depth)?;
8201            self.1.encode(encoder, offset + 4, depth)?;
8202            Ok(())
8203        }
8204    }
8205
8206    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8207        for AudioCoreSetRenderUsageGain2Request
8208    {
8209        #[inline(always)]
8210        fn new_empty() -> Self {
8211            Self {
8212                usage: fidl::new_empty!(AudioRenderUsage2, D),
8213                gain_db: fidl::new_empty!(f32, D),
8214            }
8215        }
8216
8217        #[inline]
8218        unsafe fn decode(
8219            &mut self,
8220            decoder: &mut fidl::encoding::Decoder<'_, D>,
8221            offset: usize,
8222            _depth: fidl::encoding::Depth,
8223        ) -> fidl::Result<()> {
8224            decoder.debug_check_bounds::<Self>(offset);
8225            // Verify that padding bytes are zero.
8226            fidl::decode!(AudioRenderUsage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
8227            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8228            Ok(())
8229        }
8230    }
8231
8232    impl fidl::encoding::ValueTypeMarker for AudioCoreSetRenderUsageGainRequest {
8233        type Borrowed<'a> = &'a Self;
8234        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8235            value
8236        }
8237    }
8238
8239    unsafe impl fidl::encoding::TypeMarker for AudioCoreSetRenderUsageGainRequest {
8240        type Owned = Self;
8241
8242        #[inline(always)]
8243        fn inline_align(_context: fidl::encoding::Context) -> usize {
8244            4
8245        }
8246
8247        #[inline(always)]
8248        fn inline_size(_context: fidl::encoding::Context) -> usize {
8249            8
8250        }
8251    }
8252
8253    unsafe impl<D: fidl::encoding::ResourceDialect>
8254        fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D>
8255        for &AudioCoreSetRenderUsageGainRequest
8256    {
8257        #[inline]
8258        unsafe fn encode(
8259            self,
8260            encoder: &mut fidl::encoding::Encoder<'_, D>,
8261            offset: usize,
8262            _depth: fidl::encoding::Depth,
8263        ) -> fidl::Result<()> {
8264            encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8265            // Delegate to tuple encoding.
8266            fidl::encoding::Encode::<AudioCoreSetRenderUsageGainRequest, D>::encode(
8267                (
8268                    <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
8269                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
8270                ),
8271                encoder,
8272                offset,
8273                _depth,
8274            )
8275        }
8276    }
8277    unsafe impl<
8278            D: fidl::encoding::ResourceDialect,
8279            T0: fidl::encoding::Encode<AudioRenderUsage, D>,
8280            T1: fidl::encoding::Encode<f32, D>,
8281        > fidl::encoding::Encode<AudioCoreSetRenderUsageGainRequest, D> for (T0, T1)
8282    {
8283        #[inline]
8284        unsafe fn encode(
8285            self,
8286            encoder: &mut fidl::encoding::Encoder<'_, D>,
8287            offset: usize,
8288            depth: fidl::encoding::Depth,
8289        ) -> fidl::Result<()> {
8290            encoder.debug_check_bounds::<AudioCoreSetRenderUsageGainRequest>(offset);
8291            // Zero out padding regions. There's no need to apply masks
8292            // because the unmasked parts will be overwritten by fields.
8293            // Write the fields.
8294            self.0.encode(encoder, offset + 0, depth)?;
8295            self.1.encode(encoder, offset + 4, depth)?;
8296            Ok(())
8297        }
8298    }
8299
8300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8301        for AudioCoreSetRenderUsageGainRequest
8302    {
8303        #[inline(always)]
8304        fn new_empty() -> Self {
8305            Self { usage: fidl::new_empty!(AudioRenderUsage, D), gain_db: fidl::new_empty!(f32, D) }
8306        }
8307
8308        #[inline]
8309        unsafe fn decode(
8310            &mut self,
8311            decoder: &mut fidl::encoding::Decoder<'_, D>,
8312            offset: usize,
8313            _depth: fidl::encoding::Depth,
8314        ) -> fidl::Result<()> {
8315            decoder.debug_check_bounds::<Self>(offset);
8316            // Verify that padding bytes are zero.
8317            fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
8318            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 4, _depth)?;
8319            Ok(())
8320        }
8321    }
8322
8323    impl fidl::encoding::ValueTypeMarker for AudioCoreGetDbFromVolume2Response {
8324        type Borrowed<'a> = &'a Self;
8325        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8326            value
8327        }
8328    }
8329
8330    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetDbFromVolume2Response {
8331        type Owned = Self;
8332
8333        #[inline(always)]
8334        fn inline_align(_context: fidl::encoding::Context) -> usize {
8335            4
8336        }
8337
8338        #[inline(always)]
8339        fn inline_size(_context: fidl::encoding::Context) -> usize {
8340            4
8341        }
8342    }
8343
8344    unsafe impl<D: fidl::encoding::ResourceDialect>
8345        fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D>
8346        for &AudioCoreGetDbFromVolume2Response
8347    {
8348        #[inline]
8349        unsafe fn encode(
8350            self,
8351            encoder: &mut fidl::encoding::Encoder<'_, D>,
8352            offset: usize,
8353            _depth: fidl::encoding::Depth,
8354        ) -> fidl::Result<()> {
8355            encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8356            // Delegate to tuple encoding.
8357            fidl::encoding::Encode::<AudioCoreGetDbFromVolume2Response, D>::encode(
8358                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),),
8359                encoder,
8360                offset,
8361                _depth,
8362            )
8363        }
8364    }
8365    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8366        fidl::encoding::Encode<AudioCoreGetDbFromVolume2Response, D> for (T0,)
8367    {
8368        #[inline]
8369        unsafe fn encode(
8370            self,
8371            encoder: &mut fidl::encoding::Encoder<'_, D>,
8372            offset: usize,
8373            depth: fidl::encoding::Depth,
8374        ) -> fidl::Result<()> {
8375            encoder.debug_check_bounds::<AudioCoreGetDbFromVolume2Response>(offset);
8376            // Zero out padding regions. There's no need to apply masks
8377            // because the unmasked parts will be overwritten by fields.
8378            // Write the fields.
8379            self.0.encode(encoder, offset + 0, depth)?;
8380            Ok(())
8381        }
8382    }
8383
8384    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8385        for AudioCoreGetDbFromVolume2Response
8386    {
8387        #[inline(always)]
8388        fn new_empty() -> Self {
8389            Self { gain_db: fidl::new_empty!(f32, D) }
8390        }
8391
8392        #[inline]
8393        unsafe fn decode(
8394            &mut self,
8395            decoder: &mut fidl::encoding::Decoder<'_, D>,
8396            offset: usize,
8397            _depth: fidl::encoding::Depth,
8398        ) -> fidl::Result<()> {
8399            decoder.debug_check_bounds::<Self>(offset);
8400            // Verify that padding bytes are zero.
8401            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
8402            Ok(())
8403        }
8404    }
8405
8406    impl fidl::encoding::ValueTypeMarker for AudioCoreGetVolumeFromDb2Response {
8407        type Borrowed<'a> = &'a Self;
8408        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8409            value
8410        }
8411    }
8412
8413    unsafe impl fidl::encoding::TypeMarker for AudioCoreGetVolumeFromDb2Response {
8414        type Owned = Self;
8415
8416        #[inline(always)]
8417        fn inline_align(_context: fidl::encoding::Context) -> usize {
8418            4
8419        }
8420
8421        #[inline(always)]
8422        fn inline_size(_context: fidl::encoding::Context) -> usize {
8423            4
8424        }
8425    }
8426
8427    unsafe impl<D: fidl::encoding::ResourceDialect>
8428        fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D>
8429        for &AudioCoreGetVolumeFromDb2Response
8430    {
8431        #[inline]
8432        unsafe fn encode(
8433            self,
8434            encoder: &mut fidl::encoding::Encoder<'_, D>,
8435            offset: usize,
8436            _depth: fidl::encoding::Depth,
8437        ) -> fidl::Result<()> {
8438            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8439            // Delegate to tuple encoding.
8440            fidl::encoding::Encode::<AudioCoreGetVolumeFromDb2Response, D>::encode(
8441                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.volume),),
8442                encoder,
8443                offset,
8444                _depth,
8445            )
8446        }
8447    }
8448    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
8449        fidl::encoding::Encode<AudioCoreGetVolumeFromDb2Response, D> for (T0,)
8450    {
8451        #[inline]
8452        unsafe fn encode(
8453            self,
8454            encoder: &mut fidl::encoding::Encoder<'_, D>,
8455            offset: usize,
8456            depth: fidl::encoding::Depth,
8457        ) -> fidl::Result<()> {
8458            encoder.debug_check_bounds::<AudioCoreGetVolumeFromDb2Response>(offset);
8459            // Zero out padding regions. There's no need to apply masks
8460            // because the unmasked parts will be overwritten by fields.
8461            // Write the fields.
8462            self.0.encode(encoder, offset + 0, depth)?;
8463            Ok(())
8464        }
8465    }
8466
8467    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8468        for AudioCoreGetVolumeFromDb2Response
8469    {
8470        #[inline(always)]
8471        fn new_empty() -> Self {
8472            Self { volume: fidl::new_empty!(f32, D) }
8473        }
8474
8475        #[inline]
8476        unsafe fn decode(
8477            &mut self,
8478            decoder: &mut fidl::encoding::Decoder<'_, D>,
8479            offset: usize,
8480            _depth: fidl::encoding::Depth,
8481        ) -> fidl::Result<()> {
8482            decoder.debug_check_bounds::<Self>(offset);
8483            // Verify that padding bytes are zero.
8484            fidl::decode!(f32, D, &mut self.volume, decoder, offset + 0, _depth)?;
8485            Ok(())
8486        }
8487    }
8488
8489    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8490        type Borrowed<'a> = &'a Self;
8491        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8492            value
8493        }
8494    }
8495
8496    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainRequest {
8497        type Owned = Self;
8498
8499        #[inline(always)]
8500        fn inline_align(_context: fidl::encoding::Context) -> usize {
8501            8
8502        }
8503
8504        #[inline(always)]
8505        fn inline_size(_context: fidl::encoding::Context) -> usize {
8506            8
8507        }
8508        #[inline(always)]
8509        fn encode_is_copy() -> bool {
8510            true
8511        }
8512
8513        #[inline(always)]
8514        fn decode_is_copy() -> bool {
8515            true
8516        }
8517    }
8518
8519    unsafe impl<D: fidl::encoding::ResourceDialect>
8520        fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D>
8521        for &AudioDeviceEnumeratorGetDeviceGainRequest
8522    {
8523        #[inline]
8524        unsafe fn encode(
8525            self,
8526            encoder: &mut fidl::encoding::Encoder<'_, D>,
8527            offset: usize,
8528            _depth: fidl::encoding::Depth,
8529        ) -> fidl::Result<()> {
8530            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8531            unsafe {
8532                // Copy the object into the buffer.
8533                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8534                (buf_ptr as *mut AudioDeviceEnumeratorGetDeviceGainRequest).write_unaligned(
8535                    (self as *const AudioDeviceEnumeratorGetDeviceGainRequest).read(),
8536                );
8537                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8538                // done second because the memcpy will write garbage to these bytes.
8539            }
8540            Ok(())
8541        }
8542    }
8543    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
8544        fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainRequest, D> for (T0,)
8545    {
8546        #[inline]
8547        unsafe fn encode(
8548            self,
8549            encoder: &mut fidl::encoding::Encoder<'_, D>,
8550            offset: usize,
8551            depth: fidl::encoding::Depth,
8552        ) -> fidl::Result<()> {
8553            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainRequest>(offset);
8554            // Zero out padding regions. There's no need to apply masks
8555            // because the unmasked parts will be overwritten by fields.
8556            // Write the fields.
8557            self.0.encode(encoder, offset + 0, depth)?;
8558            Ok(())
8559        }
8560    }
8561
8562    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8563        for AudioDeviceEnumeratorGetDeviceGainRequest
8564    {
8565        #[inline(always)]
8566        fn new_empty() -> Self {
8567            Self { device_token: fidl::new_empty!(u64, D) }
8568        }
8569
8570        #[inline]
8571        unsafe fn decode(
8572            &mut self,
8573            decoder: &mut fidl::encoding::Decoder<'_, D>,
8574            offset: usize,
8575            _depth: fidl::encoding::Depth,
8576        ) -> fidl::Result<()> {
8577            decoder.debug_check_bounds::<Self>(offset);
8578            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8579            // Verify that padding bytes are zero.
8580            // Copy from the buffer into the object.
8581            unsafe {
8582                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
8583            }
8584            Ok(())
8585        }
8586    }
8587
8588    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8589        type Borrowed<'a> = &'a Self;
8590        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8591            value
8592        }
8593    }
8594
8595    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDeviceGainResponse {
8596        type Owned = Self;
8597
8598        #[inline(always)]
8599        fn inline_align(_context: fidl::encoding::Context) -> usize {
8600            8
8601        }
8602
8603        #[inline(always)]
8604        fn inline_size(_context: fidl::encoding::Context) -> usize {
8605            16
8606        }
8607    }
8608
8609    unsafe impl<D: fidl::encoding::ResourceDialect>
8610        fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D>
8611        for &AudioDeviceEnumeratorGetDeviceGainResponse
8612    {
8613        #[inline]
8614        unsafe fn encode(
8615            self,
8616            encoder: &mut fidl::encoding::Encoder<'_, D>,
8617            offset: usize,
8618            _depth: fidl::encoding::Depth,
8619        ) -> fidl::Result<()> {
8620            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8621            // Delegate to tuple encoding.
8622            fidl::encoding::Encode::<AudioDeviceEnumeratorGetDeviceGainResponse, D>::encode(
8623                (
8624                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
8625                    <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
8626                ),
8627                encoder,
8628                offset,
8629                _depth,
8630            )
8631        }
8632    }
8633    unsafe impl<
8634            D: fidl::encoding::ResourceDialect,
8635            T0: fidl::encoding::Encode<u64, D>,
8636            T1: fidl::encoding::Encode<AudioGainInfo, D>,
8637        > fidl::encoding::Encode<AudioDeviceEnumeratorGetDeviceGainResponse, D> for (T0, T1)
8638    {
8639        #[inline]
8640        unsafe fn encode(
8641            self,
8642            encoder: &mut fidl::encoding::Encoder<'_, D>,
8643            offset: usize,
8644            depth: fidl::encoding::Depth,
8645        ) -> fidl::Result<()> {
8646            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDeviceGainResponse>(offset);
8647            // Zero out padding regions. There's no need to apply masks
8648            // because the unmasked parts will be overwritten by fields.
8649            // Write the fields.
8650            self.0.encode(encoder, offset + 0, depth)?;
8651            self.1.encode(encoder, offset + 8, depth)?;
8652            Ok(())
8653        }
8654    }
8655
8656    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8657        for AudioDeviceEnumeratorGetDeviceGainResponse
8658    {
8659        #[inline(always)]
8660        fn new_empty() -> Self {
8661            Self {
8662                device_token: fidl::new_empty!(u64, D),
8663                gain_info: fidl::new_empty!(AudioGainInfo, D),
8664            }
8665        }
8666
8667        #[inline]
8668        unsafe fn decode(
8669            &mut self,
8670            decoder: &mut fidl::encoding::Decoder<'_, D>,
8671            offset: usize,
8672            _depth: fidl::encoding::Depth,
8673        ) -> fidl::Result<()> {
8674            decoder.debug_check_bounds::<Self>(offset);
8675            // Verify that padding bytes are zero.
8676            fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
8677            fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
8678            Ok(())
8679        }
8680    }
8681
8682    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorGetDevicesResponse {
8683        type Borrowed<'a> = &'a Self;
8684        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8685            value
8686        }
8687    }
8688
8689    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorGetDevicesResponse {
8690        type Owned = Self;
8691
8692        #[inline(always)]
8693        fn inline_align(_context: fidl::encoding::Context) -> usize {
8694            8
8695        }
8696
8697        #[inline(always)]
8698        fn inline_size(_context: fidl::encoding::Context) -> usize {
8699            16
8700        }
8701    }
8702
8703    unsafe impl<D: fidl::encoding::ResourceDialect>
8704        fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D>
8705        for &AudioDeviceEnumeratorGetDevicesResponse
8706    {
8707        #[inline]
8708        unsafe fn encode(
8709            self,
8710            encoder: &mut fidl::encoding::Encoder<'_, D>,
8711            offset: usize,
8712            _depth: fidl::encoding::Depth,
8713        ) -> fidl::Result<()> {
8714            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8715            // Delegate to tuple encoding.
8716            fidl::encoding::Encode::<AudioDeviceEnumeratorGetDevicesResponse, D>::encode(
8717                (
8718                    <fidl::encoding::UnboundedVector<AudioDeviceInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.devices),
8719                ),
8720                encoder, offset, _depth
8721            )
8722        }
8723    }
8724    unsafe impl<
8725            D: fidl::encoding::ResourceDialect,
8726            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<AudioDeviceInfo>, D>,
8727        > fidl::encoding::Encode<AudioDeviceEnumeratorGetDevicesResponse, D> for (T0,)
8728    {
8729        #[inline]
8730        unsafe fn encode(
8731            self,
8732            encoder: &mut fidl::encoding::Encoder<'_, D>,
8733            offset: usize,
8734            depth: fidl::encoding::Depth,
8735        ) -> fidl::Result<()> {
8736            encoder.debug_check_bounds::<AudioDeviceEnumeratorGetDevicesResponse>(offset);
8737            // Zero out padding regions. There's no need to apply masks
8738            // because the unmasked parts will be overwritten by fields.
8739            // Write the fields.
8740            self.0.encode(encoder, offset + 0, depth)?;
8741            Ok(())
8742        }
8743    }
8744
8745    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8746        for AudioDeviceEnumeratorGetDevicesResponse
8747    {
8748        #[inline(always)]
8749        fn new_empty() -> Self {
8750            Self { devices: fidl::new_empty!(fidl::encoding::UnboundedVector<AudioDeviceInfo>, D) }
8751        }
8752
8753        #[inline]
8754        unsafe fn decode(
8755            &mut self,
8756            decoder: &mut fidl::encoding::Decoder<'_, D>,
8757            offset: usize,
8758            _depth: fidl::encoding::Depth,
8759        ) -> fidl::Result<()> {
8760            decoder.debug_check_bounds::<Self>(offset);
8761            // Verify that padding bytes are zero.
8762            fidl::decode!(
8763                fidl::encoding::UnboundedVector<AudioDeviceInfo>,
8764                D,
8765                &mut self.devices,
8766                decoder,
8767                offset + 0,
8768                _depth
8769            )?;
8770            Ok(())
8771        }
8772    }
8773
8774    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8775        type Borrowed<'a> = &'a Self;
8776        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8777            value
8778        }
8779    }
8780
8781    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest {
8782        type Owned = Self;
8783
8784        #[inline(always)]
8785        fn inline_align(_context: fidl::encoding::Context) -> usize {
8786            8
8787        }
8788
8789        #[inline(always)]
8790        fn inline_size(_context: fidl::encoding::Context) -> usize {
8791            16
8792        }
8793        #[inline(always)]
8794        fn encode_is_copy() -> bool {
8795            true
8796        }
8797
8798        #[inline(always)]
8799        fn decode_is_copy() -> bool {
8800            true
8801        }
8802    }
8803
8804    unsafe impl<D: fidl::encoding::ResourceDialect>
8805        fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8806        for &AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8807    {
8808        #[inline]
8809        unsafe fn encode(
8810            self,
8811            encoder: &mut fidl::encoding::Encoder<'_, D>,
8812            offset: usize,
8813            _depth: fidl::encoding::Depth,
8814        ) -> fidl::Result<()> {
8815            encoder
8816                .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8817            unsafe {
8818                // Copy the object into the buffer.
8819                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8820                (buf_ptr as *mut AudioDeviceEnumeratorOnDefaultDeviceChangedRequest)
8821                    .write_unaligned(
8822                        (self as *const AudioDeviceEnumeratorOnDefaultDeviceChangedRequest).read(),
8823                    );
8824                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8825                // done second because the memcpy will write garbage to these bytes.
8826            }
8827            Ok(())
8828        }
8829    }
8830    unsafe impl<
8831            D: fidl::encoding::ResourceDialect,
8832            T0: fidl::encoding::Encode<u64, D>,
8833            T1: fidl::encoding::Encode<u64, D>,
8834        > fidl::encoding::Encode<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest, D>
8835        for (T0, T1)
8836    {
8837        #[inline]
8838        unsafe fn encode(
8839            self,
8840            encoder: &mut fidl::encoding::Encoder<'_, D>,
8841            offset: usize,
8842            depth: fidl::encoding::Depth,
8843        ) -> fidl::Result<()> {
8844            encoder
8845                .debug_check_bounds::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(offset);
8846            // Zero out padding regions. There's no need to apply masks
8847            // because the unmasked parts will be overwritten by fields.
8848            // Write the fields.
8849            self.0.encode(encoder, offset + 0, depth)?;
8850            self.1.encode(encoder, offset + 8, depth)?;
8851            Ok(())
8852        }
8853    }
8854
8855    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8856        for AudioDeviceEnumeratorOnDefaultDeviceChangedRequest
8857    {
8858        #[inline(always)]
8859        fn new_empty() -> Self {
8860            Self {
8861                old_default_token: fidl::new_empty!(u64, D),
8862                new_default_token: fidl::new_empty!(u64, D),
8863            }
8864        }
8865
8866        #[inline]
8867        unsafe fn decode(
8868            &mut self,
8869            decoder: &mut fidl::encoding::Decoder<'_, D>,
8870            offset: usize,
8871            _depth: fidl::encoding::Depth,
8872        ) -> fidl::Result<()> {
8873            decoder.debug_check_bounds::<Self>(offset);
8874            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8875            // Verify that padding bytes are zero.
8876            // Copy from the buffer into the object.
8877            unsafe {
8878                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
8879            }
8880            Ok(())
8881        }
8882    }
8883
8884    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8885        type Borrowed<'a> = &'a Self;
8886        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8887            value
8888        }
8889    }
8890
8891    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceAddedRequest {
8892        type Owned = Self;
8893
8894        #[inline(always)]
8895        fn inline_align(_context: fidl::encoding::Context) -> usize {
8896            8
8897        }
8898
8899        #[inline(always)]
8900        fn inline_size(_context: fidl::encoding::Context) -> usize {
8901            56
8902        }
8903    }
8904
8905    unsafe impl<D: fidl::encoding::ResourceDialect>
8906        fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D>
8907        for &AudioDeviceEnumeratorOnDeviceAddedRequest
8908    {
8909        #[inline]
8910        unsafe fn encode(
8911            self,
8912            encoder: &mut fidl::encoding::Encoder<'_, D>,
8913            offset: usize,
8914            _depth: fidl::encoding::Depth,
8915        ) -> fidl::Result<()> {
8916            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8917            // Delegate to tuple encoding.
8918            fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceAddedRequest, D>::encode(
8919                (<AudioDeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
8920                encoder,
8921                offset,
8922                _depth,
8923            )
8924        }
8925    }
8926    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioDeviceInfo, D>>
8927        fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceAddedRequest, D> for (T0,)
8928    {
8929        #[inline]
8930        unsafe fn encode(
8931            self,
8932            encoder: &mut fidl::encoding::Encoder<'_, D>,
8933            offset: usize,
8934            depth: fidl::encoding::Depth,
8935        ) -> fidl::Result<()> {
8936            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceAddedRequest>(offset);
8937            // Zero out padding regions. There's no need to apply masks
8938            // because the unmasked parts will be overwritten by fields.
8939            // Write the fields.
8940            self.0.encode(encoder, offset + 0, depth)?;
8941            Ok(())
8942        }
8943    }
8944
8945    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8946        for AudioDeviceEnumeratorOnDeviceAddedRequest
8947    {
8948        #[inline(always)]
8949        fn new_empty() -> Self {
8950            Self { device: fidl::new_empty!(AudioDeviceInfo, D) }
8951        }
8952
8953        #[inline]
8954        unsafe fn decode(
8955            &mut self,
8956            decoder: &mut fidl::encoding::Decoder<'_, D>,
8957            offset: usize,
8958            _depth: fidl::encoding::Depth,
8959        ) -> fidl::Result<()> {
8960            decoder.debug_check_bounds::<Self>(offset);
8961            // Verify that padding bytes are zero.
8962            fidl::decode!(AudioDeviceInfo, D, &mut self.device, decoder, offset + 0, _depth)?;
8963            Ok(())
8964        }
8965    }
8966
8967    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceGainChangedRequest {
8968        type Borrowed<'a> = &'a Self;
8969        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8970            value
8971        }
8972    }
8973
8974    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceGainChangedRequest {
8975        type Owned = Self;
8976
8977        #[inline(always)]
8978        fn inline_align(_context: fidl::encoding::Context) -> usize {
8979            8
8980        }
8981
8982        #[inline(always)]
8983        fn inline_size(_context: fidl::encoding::Context) -> usize {
8984            16
8985        }
8986    }
8987
8988    unsafe impl<D: fidl::encoding::ResourceDialect>
8989        fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>
8990        for &AudioDeviceEnumeratorOnDeviceGainChangedRequest
8991    {
8992        #[inline]
8993        unsafe fn encode(
8994            self,
8995            encoder: &mut fidl::encoding::Encoder<'_, D>,
8996            offset: usize,
8997            _depth: fidl::encoding::Depth,
8998        ) -> fidl::Result<()> {
8999            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
9000            // Delegate to tuple encoding.
9001            fidl::encoding::Encode::<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D>::encode(
9002                (
9003                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
9004                    <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9005                ),
9006                encoder,
9007                offset,
9008                _depth,
9009            )
9010        }
9011    }
9012    unsafe impl<
9013            D: fidl::encoding::ResourceDialect,
9014            T0: fidl::encoding::Encode<u64, D>,
9015            T1: fidl::encoding::Encode<AudioGainInfo, D>,
9016        > fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceGainChangedRequest, D> for (T0, T1)
9017    {
9018        #[inline]
9019        unsafe fn encode(
9020            self,
9021            encoder: &mut fidl::encoding::Encoder<'_, D>,
9022            offset: usize,
9023            depth: fidl::encoding::Depth,
9024        ) -> fidl::Result<()> {
9025            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(offset);
9026            // Zero out padding regions. There's no need to apply masks
9027            // because the unmasked parts will be overwritten by fields.
9028            // Write the fields.
9029            self.0.encode(encoder, offset + 0, depth)?;
9030            self.1.encode(encoder, offset + 8, depth)?;
9031            Ok(())
9032        }
9033    }
9034
9035    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9036        for AudioDeviceEnumeratorOnDeviceGainChangedRequest
9037    {
9038        #[inline(always)]
9039        fn new_empty() -> Self {
9040            Self {
9041                device_token: fidl::new_empty!(u64, D),
9042                gain_info: fidl::new_empty!(AudioGainInfo, D),
9043            }
9044        }
9045
9046        #[inline]
9047        unsafe fn decode(
9048            &mut self,
9049            decoder: &mut fidl::encoding::Decoder<'_, D>,
9050            offset: usize,
9051            _depth: fidl::encoding::Depth,
9052        ) -> fidl::Result<()> {
9053            decoder.debug_check_bounds::<Self>(offset);
9054            // Verify that padding bytes are zero.
9055            fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
9056            fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
9057            Ok(())
9058        }
9059    }
9060
9061    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
9062        type Borrowed<'a> = &'a Self;
9063        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9064            value
9065        }
9066    }
9067
9068    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorOnDeviceRemovedRequest {
9069        type Owned = Self;
9070
9071        #[inline(always)]
9072        fn inline_align(_context: fidl::encoding::Context) -> usize {
9073            8
9074        }
9075
9076        #[inline(always)]
9077        fn inline_size(_context: fidl::encoding::Context) -> usize {
9078            8
9079        }
9080        #[inline(always)]
9081        fn encode_is_copy() -> bool {
9082            true
9083        }
9084
9085        #[inline(always)]
9086        fn decode_is_copy() -> bool {
9087            true
9088        }
9089    }
9090
9091    unsafe impl<D: fidl::encoding::ResourceDialect>
9092        fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D>
9093        for &AudioDeviceEnumeratorOnDeviceRemovedRequest
9094    {
9095        #[inline]
9096        unsafe fn encode(
9097            self,
9098            encoder: &mut fidl::encoding::Encoder<'_, D>,
9099            offset: usize,
9100            _depth: fidl::encoding::Depth,
9101        ) -> fidl::Result<()> {
9102            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
9103            unsafe {
9104                // Copy the object into the buffer.
9105                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9106                (buf_ptr as *mut AudioDeviceEnumeratorOnDeviceRemovedRequest).write_unaligned(
9107                    (self as *const AudioDeviceEnumeratorOnDeviceRemovedRequest).read(),
9108                );
9109                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9110                // done second because the memcpy will write garbage to these bytes.
9111            }
9112            Ok(())
9113        }
9114    }
9115    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
9116        fidl::encoding::Encode<AudioDeviceEnumeratorOnDeviceRemovedRequest, D> for (T0,)
9117    {
9118        #[inline]
9119        unsafe fn encode(
9120            self,
9121            encoder: &mut fidl::encoding::Encoder<'_, D>,
9122            offset: usize,
9123            depth: fidl::encoding::Depth,
9124        ) -> fidl::Result<()> {
9125            encoder.debug_check_bounds::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(offset);
9126            // Zero out padding regions. There's no need to apply masks
9127            // because the unmasked parts will be overwritten by fields.
9128            // Write the fields.
9129            self.0.encode(encoder, offset + 0, depth)?;
9130            Ok(())
9131        }
9132    }
9133
9134    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9135        for AudioDeviceEnumeratorOnDeviceRemovedRequest
9136    {
9137        #[inline(always)]
9138        fn new_empty() -> Self {
9139            Self { device_token: fidl::new_empty!(u64, D) }
9140        }
9141
9142        #[inline]
9143        unsafe fn decode(
9144            &mut self,
9145            decoder: &mut fidl::encoding::Decoder<'_, D>,
9146            offset: usize,
9147            _depth: fidl::encoding::Depth,
9148        ) -> fidl::Result<()> {
9149            decoder.debug_check_bounds::<Self>(offset);
9150            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9151            // Verify that padding bytes are zero.
9152            // Copy from the buffer into the object.
9153            unsafe {
9154                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9155            }
9156            Ok(())
9157        }
9158    }
9159
9160    impl fidl::encoding::ValueTypeMarker for AudioDeviceEnumeratorSetDeviceGainRequest {
9161        type Borrowed<'a> = &'a Self;
9162        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9163            value
9164        }
9165    }
9166
9167    unsafe impl fidl::encoding::TypeMarker for AudioDeviceEnumeratorSetDeviceGainRequest {
9168        type Owned = Self;
9169
9170        #[inline(always)]
9171        fn inline_align(_context: fidl::encoding::Context) -> usize {
9172            8
9173        }
9174
9175        #[inline(always)]
9176        fn inline_size(_context: fidl::encoding::Context) -> usize {
9177            24
9178        }
9179    }
9180
9181    unsafe impl<D: fidl::encoding::ResourceDialect>
9182        fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D>
9183        for &AudioDeviceEnumeratorSetDeviceGainRequest
9184    {
9185        #[inline]
9186        unsafe fn encode(
9187            self,
9188            encoder: &mut fidl::encoding::Encoder<'_, D>,
9189            offset: usize,
9190            _depth: fidl::encoding::Depth,
9191        ) -> fidl::Result<()> {
9192            encoder.debug_check_bounds::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9193            // Delegate to tuple encoding.
9194            fidl::encoding::Encode::<AudioDeviceEnumeratorSetDeviceGainRequest, D>::encode(
9195                (
9196                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.device_token),
9197                    <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9198                    <AudioGainValidFlags as fidl::encoding::ValueTypeMarker>::borrow(
9199                        &self.valid_flags,
9200                    ),
9201                ),
9202                encoder,
9203                offset,
9204                _depth,
9205            )
9206        }
9207    }
9208    unsafe impl<
9209            D: fidl::encoding::ResourceDialect,
9210            T0: fidl::encoding::Encode<u64, D>,
9211            T1: fidl::encoding::Encode<AudioGainInfo, D>,
9212            T2: fidl::encoding::Encode<AudioGainValidFlags, D>,
9213        > fidl::encoding::Encode<AudioDeviceEnumeratorSetDeviceGainRequest, D> for (T0, T1, T2)
9214    {
9215        #[inline]
9216        unsafe fn encode(
9217            self,
9218            encoder: &mut fidl::encoding::Encoder<'_, D>,
9219            offset: usize,
9220            depth: fidl::encoding::Depth,
9221        ) -> fidl::Result<()> {
9222            encoder.debug_check_bounds::<AudioDeviceEnumeratorSetDeviceGainRequest>(offset);
9223            // Zero out padding regions. There's no need to apply masks
9224            // because the unmasked parts will be overwritten by fields.
9225            unsafe {
9226                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
9227                (ptr as *mut u64).write_unaligned(0);
9228            }
9229            // Write the fields.
9230            self.0.encode(encoder, offset + 0, depth)?;
9231            self.1.encode(encoder, offset + 8, depth)?;
9232            self.2.encode(encoder, offset + 16, depth)?;
9233            Ok(())
9234        }
9235    }
9236
9237    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9238        for AudioDeviceEnumeratorSetDeviceGainRequest
9239    {
9240        #[inline(always)]
9241        fn new_empty() -> Self {
9242            Self {
9243                device_token: fidl::new_empty!(u64, D),
9244                gain_info: fidl::new_empty!(AudioGainInfo, D),
9245                valid_flags: fidl::new_empty!(AudioGainValidFlags, D),
9246            }
9247        }
9248
9249        #[inline]
9250        unsafe fn decode(
9251            &mut self,
9252            decoder: &mut fidl::encoding::Decoder<'_, D>,
9253            offset: usize,
9254            _depth: fidl::encoding::Depth,
9255        ) -> fidl::Result<()> {
9256            decoder.debug_check_bounds::<Self>(offset);
9257            // Verify that padding bytes are zero.
9258            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
9259            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9260            let mask = 0xffffffff00000000u64;
9261            let maskedval = padval & mask;
9262            if maskedval != 0 {
9263                return Err(fidl::Error::NonZeroPadding {
9264                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
9265                });
9266            }
9267            fidl::decode!(u64, D, &mut self.device_token, decoder, offset + 0, _depth)?;
9268            fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 8, _depth)?;
9269            fidl::decode!(
9270                AudioGainValidFlags,
9271                D,
9272                &mut self.valid_flags,
9273                decoder,
9274                offset + 16,
9275                _depth
9276            )?;
9277            Ok(())
9278        }
9279    }
9280
9281    impl fidl::encoding::ValueTypeMarker for AudioDeviceInfo {
9282        type Borrowed<'a> = &'a Self;
9283        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9284            value
9285        }
9286    }
9287
9288    unsafe impl fidl::encoding::TypeMarker for AudioDeviceInfo {
9289        type Owned = Self;
9290
9291        #[inline(always)]
9292        fn inline_align(_context: fidl::encoding::Context) -> usize {
9293            8
9294        }
9295
9296        #[inline(always)]
9297        fn inline_size(_context: fidl::encoding::Context) -> usize {
9298            56
9299        }
9300    }
9301
9302    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioDeviceInfo, D>
9303        for &AudioDeviceInfo
9304    {
9305        #[inline]
9306        unsafe fn encode(
9307            self,
9308            encoder: &mut fidl::encoding::Encoder<'_, D>,
9309            offset: usize,
9310            _depth: fidl::encoding::Depth,
9311        ) -> fidl::Result<()> {
9312            encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9313            // Delegate to tuple encoding.
9314            fidl::encoding::Encode::<AudioDeviceInfo, D>::encode(
9315                (
9316                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9317                        &self.name,
9318                    ),
9319                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
9320                        &self.unique_id,
9321                    ),
9322                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.token_id),
9323                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_input),
9324                    <AudioGainInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_info),
9325                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_default),
9326                ),
9327                encoder,
9328                offset,
9329                _depth,
9330            )
9331        }
9332    }
9333    unsafe impl<
9334            D: fidl::encoding::ResourceDialect,
9335            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9336            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
9337            T2: fidl::encoding::Encode<u64, D>,
9338            T3: fidl::encoding::Encode<bool, D>,
9339            T4: fidl::encoding::Encode<AudioGainInfo, D>,
9340            T5: fidl::encoding::Encode<bool, D>,
9341        > fidl::encoding::Encode<AudioDeviceInfo, D> for (T0, T1, T2, T3, T4, T5)
9342    {
9343        #[inline]
9344        unsafe fn encode(
9345            self,
9346            encoder: &mut fidl::encoding::Encoder<'_, D>,
9347            offset: usize,
9348            depth: fidl::encoding::Depth,
9349        ) -> fidl::Result<()> {
9350            encoder.debug_check_bounds::<AudioDeviceInfo>(offset);
9351            // Zero out padding regions. There's no need to apply masks
9352            // because the unmasked parts will be overwritten by fields.
9353            unsafe {
9354                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
9355                (ptr as *mut u64).write_unaligned(0);
9356            }
9357            unsafe {
9358                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
9359                (ptr as *mut u64).write_unaligned(0);
9360            }
9361            // Write the fields.
9362            self.0.encode(encoder, offset + 0, depth)?;
9363            self.1.encode(encoder, offset + 16, depth)?;
9364            self.2.encode(encoder, offset + 32, depth)?;
9365            self.3.encode(encoder, offset + 40, depth)?;
9366            self.4.encode(encoder, offset + 44, depth)?;
9367            self.5.encode(encoder, offset + 52, depth)?;
9368            Ok(())
9369        }
9370    }
9371
9372    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioDeviceInfo {
9373        #[inline(always)]
9374        fn new_empty() -> Self {
9375            Self {
9376                name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9377                unique_id: fidl::new_empty!(fidl::encoding::UnboundedString, D),
9378                token_id: fidl::new_empty!(u64, D),
9379                is_input: fidl::new_empty!(bool, D),
9380                gain_info: fidl::new_empty!(AudioGainInfo, D),
9381                is_default: fidl::new_empty!(bool, D),
9382            }
9383        }
9384
9385        #[inline]
9386        unsafe fn decode(
9387            &mut self,
9388            decoder: &mut fidl::encoding::Decoder<'_, D>,
9389            offset: usize,
9390            _depth: fidl::encoding::Depth,
9391        ) -> fidl::Result<()> {
9392            decoder.debug_check_bounds::<Self>(offset);
9393            // Verify that padding bytes are zero.
9394            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
9395            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9396            let mask = 0xffffff00u64;
9397            let maskedval = padval & mask;
9398            if maskedval != 0 {
9399                return Err(fidl::Error::NonZeroPadding {
9400                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
9401                });
9402            }
9403            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
9404            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9405            let mask = 0xffffff0000000000u64;
9406            let maskedval = padval & mask;
9407            if maskedval != 0 {
9408                return Err(fidl::Error::NonZeroPadding {
9409                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
9410                });
9411            }
9412            fidl::decode!(
9413                fidl::encoding::UnboundedString,
9414                D,
9415                &mut self.name,
9416                decoder,
9417                offset + 0,
9418                _depth
9419            )?;
9420            fidl::decode!(
9421                fidl::encoding::UnboundedString,
9422                D,
9423                &mut self.unique_id,
9424                decoder,
9425                offset + 16,
9426                _depth
9427            )?;
9428            fidl::decode!(u64, D, &mut self.token_id, decoder, offset + 32, _depth)?;
9429            fidl::decode!(bool, D, &mut self.is_input, decoder, offset + 40, _depth)?;
9430            fidl::decode!(AudioGainInfo, D, &mut self.gain_info, decoder, offset + 44, _depth)?;
9431            fidl::decode!(bool, D, &mut self.is_default, decoder, offset + 52, _depth)?;
9432            Ok(())
9433        }
9434    }
9435
9436    impl fidl::encoding::ValueTypeMarker for AudioGainInfo {
9437        type Borrowed<'a> = &'a Self;
9438        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9439            value
9440        }
9441    }
9442
9443    unsafe impl fidl::encoding::TypeMarker for AudioGainInfo {
9444        type Owned = Self;
9445
9446        #[inline(always)]
9447        fn inline_align(_context: fidl::encoding::Context) -> usize {
9448            4
9449        }
9450
9451        #[inline(always)]
9452        fn inline_size(_context: fidl::encoding::Context) -> usize {
9453            8
9454        }
9455    }
9456
9457    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioGainInfo, D>
9458        for &AudioGainInfo
9459    {
9460        #[inline]
9461        unsafe fn encode(
9462            self,
9463            encoder: &mut fidl::encoding::Encoder<'_, D>,
9464            offset: usize,
9465            _depth: fidl::encoding::Depth,
9466        ) -> fidl::Result<()> {
9467            encoder.debug_check_bounds::<AudioGainInfo>(offset);
9468            // Delegate to tuple encoding.
9469            fidl::encoding::Encode::<AudioGainInfo, D>::encode(
9470                (
9471                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_db),
9472                    <AudioGainInfoFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
9473                ),
9474                encoder,
9475                offset,
9476                _depth,
9477            )
9478        }
9479    }
9480    unsafe impl<
9481            D: fidl::encoding::ResourceDialect,
9482            T0: fidl::encoding::Encode<f32, D>,
9483            T1: fidl::encoding::Encode<AudioGainInfoFlags, D>,
9484        > fidl::encoding::Encode<AudioGainInfo, D> for (T0, T1)
9485    {
9486        #[inline]
9487        unsafe fn encode(
9488            self,
9489            encoder: &mut fidl::encoding::Encoder<'_, D>,
9490            offset: usize,
9491            depth: fidl::encoding::Depth,
9492        ) -> fidl::Result<()> {
9493            encoder.debug_check_bounds::<AudioGainInfo>(offset);
9494            // Zero out padding regions. There's no need to apply masks
9495            // because the unmasked parts will be overwritten by fields.
9496            // Write the fields.
9497            self.0.encode(encoder, offset + 0, depth)?;
9498            self.1.encode(encoder, offset + 4, depth)?;
9499            Ok(())
9500        }
9501    }
9502
9503    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioGainInfo {
9504        #[inline(always)]
9505        fn new_empty() -> Self {
9506            Self {
9507                gain_db: fidl::new_empty!(f32, D),
9508                flags: fidl::new_empty!(AudioGainInfoFlags, D),
9509            }
9510        }
9511
9512        #[inline]
9513        unsafe fn decode(
9514            &mut self,
9515            decoder: &mut fidl::encoding::Decoder<'_, D>,
9516            offset: usize,
9517            _depth: fidl::encoding::Depth,
9518        ) -> fidl::Result<()> {
9519            decoder.debug_check_bounds::<Self>(offset);
9520            // Verify that padding bytes are zero.
9521            fidl::decode!(f32, D, &mut self.gain_db, decoder, offset + 0, _depth)?;
9522            fidl::decode!(AudioGainInfoFlags, D, &mut self.flags, decoder, offset + 4, _depth)?;
9523            Ok(())
9524        }
9525    }
9526
9527    impl fidl::encoding::ValueTypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9528        type Borrowed<'a> = &'a Self;
9529        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9530            value
9531        }
9532    }
9533
9534    unsafe impl fidl::encoding::TypeMarker for AudioRendererEnableMinLeadTimeEventsRequest {
9535        type Owned = Self;
9536
9537        #[inline(always)]
9538        fn inline_align(_context: fidl::encoding::Context) -> usize {
9539            1
9540        }
9541
9542        #[inline(always)]
9543        fn inline_size(_context: fidl::encoding::Context) -> usize {
9544            1
9545        }
9546    }
9547
9548    unsafe impl<D: fidl::encoding::ResourceDialect>
9549        fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D>
9550        for &AudioRendererEnableMinLeadTimeEventsRequest
9551    {
9552        #[inline]
9553        unsafe fn encode(
9554            self,
9555            encoder: &mut fidl::encoding::Encoder<'_, D>,
9556            offset: usize,
9557            _depth: fidl::encoding::Depth,
9558        ) -> fidl::Result<()> {
9559            encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9560            // Delegate to tuple encoding.
9561            fidl::encoding::Encode::<AudioRendererEnableMinLeadTimeEventsRequest, D>::encode(
9562                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
9563                encoder,
9564                offset,
9565                _depth,
9566            )
9567        }
9568    }
9569    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
9570        fidl::encoding::Encode<AudioRendererEnableMinLeadTimeEventsRequest, D> for (T0,)
9571    {
9572        #[inline]
9573        unsafe fn encode(
9574            self,
9575            encoder: &mut fidl::encoding::Encoder<'_, D>,
9576            offset: usize,
9577            depth: fidl::encoding::Depth,
9578        ) -> fidl::Result<()> {
9579            encoder.debug_check_bounds::<AudioRendererEnableMinLeadTimeEventsRequest>(offset);
9580            // 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 AudioRendererEnableMinLeadTimeEventsRequest
9590    {
9591        #[inline(always)]
9592        fn new_empty() -> Self {
9593            Self { enabled: fidl::new_empty!(bool, D) }
9594        }
9595
9596        #[inline]
9597        unsafe fn decode(
9598            &mut self,
9599            decoder: &mut fidl::encoding::Decoder<'_, D>,
9600            offset: usize,
9601            _depth: fidl::encoding::Depth,
9602        ) -> fidl::Result<()> {
9603            decoder.debug_check_bounds::<Self>(offset);
9604            // Verify that padding bytes are zero.
9605            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
9606            Ok(())
9607        }
9608    }
9609
9610    impl fidl::encoding::ValueTypeMarker for AudioRendererGetMinLeadTimeResponse {
9611        type Borrowed<'a> = &'a Self;
9612        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9613            value
9614        }
9615    }
9616
9617    unsafe impl fidl::encoding::TypeMarker for AudioRendererGetMinLeadTimeResponse {
9618        type Owned = Self;
9619
9620        #[inline(always)]
9621        fn inline_align(_context: fidl::encoding::Context) -> usize {
9622            8
9623        }
9624
9625        #[inline(always)]
9626        fn inline_size(_context: fidl::encoding::Context) -> usize {
9627            8
9628        }
9629        #[inline(always)]
9630        fn encode_is_copy() -> bool {
9631            true
9632        }
9633
9634        #[inline(always)]
9635        fn decode_is_copy() -> bool {
9636            true
9637        }
9638    }
9639
9640    unsafe impl<D: fidl::encoding::ResourceDialect>
9641        fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D>
9642        for &AudioRendererGetMinLeadTimeResponse
9643    {
9644        #[inline]
9645        unsafe fn encode(
9646            self,
9647            encoder: &mut fidl::encoding::Encoder<'_, D>,
9648            offset: usize,
9649            _depth: fidl::encoding::Depth,
9650        ) -> fidl::Result<()> {
9651            encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9652            unsafe {
9653                // Copy the object into the buffer.
9654                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9655                (buf_ptr as *mut AudioRendererGetMinLeadTimeResponse)
9656                    .write_unaligned((self as *const AudioRendererGetMinLeadTimeResponse).read());
9657                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9658                // done second because the memcpy will write garbage to these bytes.
9659            }
9660            Ok(())
9661        }
9662    }
9663    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9664        fidl::encoding::Encode<AudioRendererGetMinLeadTimeResponse, D> for (T0,)
9665    {
9666        #[inline]
9667        unsafe fn encode(
9668            self,
9669            encoder: &mut fidl::encoding::Encoder<'_, D>,
9670            offset: usize,
9671            depth: fidl::encoding::Depth,
9672        ) -> fidl::Result<()> {
9673            encoder.debug_check_bounds::<AudioRendererGetMinLeadTimeResponse>(offset);
9674            // Zero out padding regions. There's no need to apply masks
9675            // because the unmasked parts will be overwritten by fields.
9676            // Write the fields.
9677            self.0.encode(encoder, offset + 0, depth)?;
9678            Ok(())
9679        }
9680    }
9681
9682    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9683        for AudioRendererGetMinLeadTimeResponse
9684    {
9685        #[inline(always)]
9686        fn new_empty() -> Self {
9687            Self { min_lead_time_nsec: fidl::new_empty!(i64, D) }
9688        }
9689
9690        #[inline]
9691        unsafe fn decode(
9692            &mut self,
9693            decoder: &mut fidl::encoding::Decoder<'_, D>,
9694            offset: usize,
9695            _depth: fidl::encoding::Depth,
9696        ) -> fidl::Result<()> {
9697            decoder.debug_check_bounds::<Self>(offset);
9698            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9699            // Verify that padding bytes are zero.
9700            // Copy from the buffer into the object.
9701            unsafe {
9702                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9703            }
9704            Ok(())
9705        }
9706    }
9707
9708    impl fidl::encoding::ValueTypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9709        type Borrowed<'a> = &'a Self;
9710        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9711            value
9712        }
9713    }
9714
9715    unsafe impl fidl::encoding::TypeMarker for AudioRendererOnMinLeadTimeChangedRequest {
9716        type Owned = Self;
9717
9718        #[inline(always)]
9719        fn inline_align(_context: fidl::encoding::Context) -> usize {
9720            8
9721        }
9722
9723        #[inline(always)]
9724        fn inline_size(_context: fidl::encoding::Context) -> usize {
9725            8
9726        }
9727        #[inline(always)]
9728        fn encode_is_copy() -> bool {
9729            true
9730        }
9731
9732        #[inline(always)]
9733        fn decode_is_copy() -> bool {
9734            true
9735        }
9736    }
9737
9738    unsafe impl<D: fidl::encoding::ResourceDialect>
9739        fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, D>
9740        for &AudioRendererOnMinLeadTimeChangedRequest
9741    {
9742        #[inline]
9743        unsafe fn encode(
9744            self,
9745            encoder: &mut fidl::encoding::Encoder<'_, D>,
9746            offset: usize,
9747            _depth: fidl::encoding::Depth,
9748        ) -> fidl::Result<()> {
9749            encoder.debug_check_bounds::<AudioRendererOnMinLeadTimeChangedRequest>(offset);
9750            unsafe {
9751                // Copy the object into the buffer.
9752                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9753                (buf_ptr as *mut AudioRendererOnMinLeadTimeChangedRequest).write_unaligned(
9754                    (self as *const AudioRendererOnMinLeadTimeChangedRequest).read(),
9755                );
9756                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9757                // done second because the memcpy will write garbage to these bytes.
9758            }
9759            Ok(())
9760        }
9761    }
9762    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
9763        fidl::encoding::Encode<AudioRendererOnMinLeadTimeChangedRequest, D> for (T0,)
9764    {
9765        #[inline]
9766        unsafe fn encode(
9767            self,
9768            encoder: &mut fidl::encoding::Encoder<'_, D>,
9769            offset: usize,
9770            depth: fidl::encoding::Depth,
9771        ) -> fidl::Result<()> {
9772            encoder.debug_check_bounds::<AudioRendererOnMinLeadTimeChangedRequest>(offset);
9773            // Zero out padding regions. There's no need to apply masks
9774            // because the unmasked parts will be overwritten by fields.
9775            // Write the fields.
9776            self.0.encode(encoder, offset + 0, depth)?;
9777            Ok(())
9778        }
9779    }
9780
9781    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9782        for AudioRendererOnMinLeadTimeChangedRequest
9783    {
9784        #[inline(always)]
9785        fn new_empty() -> Self {
9786            Self { min_lead_time_nsec: fidl::new_empty!(i64, D) }
9787        }
9788
9789        #[inline]
9790        unsafe fn decode(
9791            &mut self,
9792            decoder: &mut fidl::encoding::Decoder<'_, D>,
9793            offset: usize,
9794            _depth: fidl::encoding::Depth,
9795        ) -> fidl::Result<()> {
9796            decoder.debug_check_bounds::<Self>(offset);
9797            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9798            // Verify that padding bytes are zero.
9799            // Copy from the buffer into the object.
9800            unsafe {
9801                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
9802            }
9803            Ok(())
9804        }
9805    }
9806
9807    impl fidl::encoding::ValueTypeMarker for AudioRendererPauseResponse {
9808        type Borrowed<'a> = &'a Self;
9809        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9810            value
9811        }
9812    }
9813
9814    unsafe impl fidl::encoding::TypeMarker for AudioRendererPauseResponse {
9815        type Owned = Self;
9816
9817        #[inline(always)]
9818        fn inline_align(_context: fidl::encoding::Context) -> usize {
9819            8
9820        }
9821
9822        #[inline(always)]
9823        fn inline_size(_context: fidl::encoding::Context) -> usize {
9824            16
9825        }
9826        #[inline(always)]
9827        fn encode_is_copy() -> bool {
9828            true
9829        }
9830
9831        #[inline(always)]
9832        fn decode_is_copy() -> bool {
9833            true
9834        }
9835    }
9836
9837    unsafe impl<D: fidl::encoding::ResourceDialect>
9838        fidl::encoding::Encode<AudioRendererPauseResponse, D> for &AudioRendererPauseResponse
9839    {
9840        #[inline]
9841        unsafe fn encode(
9842            self,
9843            encoder: &mut fidl::encoding::Encoder<'_, D>,
9844            offset: usize,
9845            _depth: fidl::encoding::Depth,
9846        ) -> fidl::Result<()> {
9847            encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9848            unsafe {
9849                // Copy the object into the buffer.
9850                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9851                (buf_ptr as *mut AudioRendererPauseResponse)
9852                    .write_unaligned((self as *const AudioRendererPauseResponse).read());
9853                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9854                // done second because the memcpy will write garbage to these bytes.
9855            }
9856            Ok(())
9857        }
9858    }
9859    unsafe impl<
9860            D: fidl::encoding::ResourceDialect,
9861            T0: fidl::encoding::Encode<i64, D>,
9862            T1: fidl::encoding::Encode<i64, D>,
9863        > fidl::encoding::Encode<AudioRendererPauseResponse, D> for (T0, T1)
9864    {
9865        #[inline]
9866        unsafe fn encode(
9867            self,
9868            encoder: &mut fidl::encoding::Encoder<'_, D>,
9869            offset: usize,
9870            depth: fidl::encoding::Depth,
9871        ) -> fidl::Result<()> {
9872            encoder.debug_check_bounds::<AudioRendererPauseResponse>(offset);
9873            // Zero out padding regions. There's no need to apply masks
9874            // because the unmasked parts will be overwritten by fields.
9875            // Write the fields.
9876            self.0.encode(encoder, offset + 0, depth)?;
9877            self.1.encode(encoder, offset + 8, depth)?;
9878            Ok(())
9879        }
9880    }
9881
9882    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9883        for AudioRendererPauseResponse
9884    {
9885        #[inline(always)]
9886        fn new_empty() -> Self {
9887            Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9888        }
9889
9890        #[inline]
9891        unsafe fn decode(
9892            &mut self,
9893            decoder: &mut fidl::encoding::Decoder<'_, D>,
9894            offset: usize,
9895            _depth: fidl::encoding::Depth,
9896        ) -> fidl::Result<()> {
9897            decoder.debug_check_bounds::<Self>(offset);
9898            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9899            // Verify that padding bytes are zero.
9900            // Copy from the buffer into the object.
9901            unsafe {
9902                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
9903            }
9904            Ok(())
9905        }
9906    }
9907
9908    impl fidl::encoding::ValueTypeMarker for AudioRendererPlayNoReplyRequest {
9909        type Borrowed<'a> = &'a Self;
9910        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9911            value
9912        }
9913    }
9914
9915    unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayNoReplyRequest {
9916        type Owned = Self;
9917
9918        #[inline(always)]
9919        fn inline_align(_context: fidl::encoding::Context) -> usize {
9920            8
9921        }
9922
9923        #[inline(always)]
9924        fn inline_size(_context: fidl::encoding::Context) -> usize {
9925            16
9926        }
9927        #[inline(always)]
9928        fn encode_is_copy() -> bool {
9929            true
9930        }
9931
9932        #[inline(always)]
9933        fn decode_is_copy() -> bool {
9934            true
9935        }
9936    }
9937
9938    unsafe impl<D: fidl::encoding::ResourceDialect>
9939        fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D>
9940        for &AudioRendererPlayNoReplyRequest
9941    {
9942        #[inline]
9943        unsafe fn encode(
9944            self,
9945            encoder: &mut fidl::encoding::Encoder<'_, D>,
9946            offset: usize,
9947            _depth: fidl::encoding::Depth,
9948        ) -> fidl::Result<()> {
9949            encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9950            unsafe {
9951                // Copy the object into the buffer.
9952                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9953                (buf_ptr as *mut AudioRendererPlayNoReplyRequest)
9954                    .write_unaligned((self as *const AudioRendererPlayNoReplyRequest).read());
9955                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9956                // done second because the memcpy will write garbage to these bytes.
9957            }
9958            Ok(())
9959        }
9960    }
9961    unsafe impl<
9962            D: fidl::encoding::ResourceDialect,
9963            T0: fidl::encoding::Encode<i64, D>,
9964            T1: fidl::encoding::Encode<i64, D>,
9965        > fidl::encoding::Encode<AudioRendererPlayNoReplyRequest, D> for (T0, T1)
9966    {
9967        #[inline]
9968        unsafe fn encode(
9969            self,
9970            encoder: &mut fidl::encoding::Encoder<'_, D>,
9971            offset: usize,
9972            depth: fidl::encoding::Depth,
9973        ) -> fidl::Result<()> {
9974            encoder.debug_check_bounds::<AudioRendererPlayNoReplyRequest>(offset);
9975            // Zero out padding regions. There's no need to apply masks
9976            // because the unmasked parts will be overwritten by fields.
9977            // Write the fields.
9978            self.0.encode(encoder, offset + 0, depth)?;
9979            self.1.encode(encoder, offset + 8, depth)?;
9980            Ok(())
9981        }
9982    }
9983
9984    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9985        for AudioRendererPlayNoReplyRequest
9986    {
9987        #[inline(always)]
9988        fn new_empty() -> Self {
9989            Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
9990        }
9991
9992        #[inline]
9993        unsafe fn decode(
9994            &mut self,
9995            decoder: &mut fidl::encoding::Decoder<'_, D>,
9996            offset: usize,
9997            _depth: fidl::encoding::Depth,
9998        ) -> fidl::Result<()> {
9999            decoder.debug_check_bounds::<Self>(offset);
10000            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10001            // Verify that padding bytes are zero.
10002            // Copy from the buffer into the object.
10003            unsafe {
10004                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10005            }
10006            Ok(())
10007        }
10008    }
10009
10010    impl fidl::encoding::ValueTypeMarker for AudioRendererPlayRequest {
10011        type Borrowed<'a> = &'a Self;
10012        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10013            value
10014        }
10015    }
10016
10017    unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayRequest {
10018        type Owned = Self;
10019
10020        #[inline(always)]
10021        fn inline_align(_context: fidl::encoding::Context) -> usize {
10022            8
10023        }
10024
10025        #[inline(always)]
10026        fn inline_size(_context: fidl::encoding::Context) -> usize {
10027            16
10028        }
10029        #[inline(always)]
10030        fn encode_is_copy() -> bool {
10031            true
10032        }
10033
10034        #[inline(always)]
10035        fn decode_is_copy() -> bool {
10036            true
10037        }
10038    }
10039
10040    unsafe impl<D: fidl::encoding::ResourceDialect>
10041        fidl::encoding::Encode<AudioRendererPlayRequest, D> for &AudioRendererPlayRequest
10042    {
10043        #[inline]
10044        unsafe fn encode(
10045            self,
10046            encoder: &mut fidl::encoding::Encoder<'_, D>,
10047            offset: usize,
10048            _depth: fidl::encoding::Depth,
10049        ) -> fidl::Result<()> {
10050            encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
10051            unsafe {
10052                // Copy the object into the buffer.
10053                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10054                (buf_ptr as *mut AudioRendererPlayRequest)
10055                    .write_unaligned((self as *const AudioRendererPlayRequest).read());
10056                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10057                // done second because the memcpy will write garbage to these bytes.
10058            }
10059            Ok(())
10060        }
10061    }
10062    unsafe impl<
10063            D: fidl::encoding::ResourceDialect,
10064            T0: fidl::encoding::Encode<i64, D>,
10065            T1: fidl::encoding::Encode<i64, D>,
10066        > fidl::encoding::Encode<AudioRendererPlayRequest, D> for (T0, T1)
10067    {
10068        #[inline]
10069        unsafe fn encode(
10070            self,
10071            encoder: &mut fidl::encoding::Encoder<'_, D>,
10072            offset: usize,
10073            depth: fidl::encoding::Depth,
10074        ) -> fidl::Result<()> {
10075            encoder.debug_check_bounds::<AudioRendererPlayRequest>(offset);
10076            // Zero out padding regions. There's no need to apply masks
10077            // because the unmasked parts will be overwritten by fields.
10078            // Write the fields.
10079            self.0.encode(encoder, offset + 0, depth)?;
10080            self.1.encode(encoder, offset + 8, depth)?;
10081            Ok(())
10082        }
10083    }
10084
10085    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10086        for AudioRendererPlayRequest
10087    {
10088        #[inline(always)]
10089        fn new_empty() -> Self {
10090            Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
10091        }
10092
10093        #[inline]
10094        unsafe fn decode(
10095            &mut self,
10096            decoder: &mut fidl::encoding::Decoder<'_, D>,
10097            offset: usize,
10098            _depth: fidl::encoding::Depth,
10099        ) -> fidl::Result<()> {
10100            decoder.debug_check_bounds::<Self>(offset);
10101            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10102            // Verify that padding bytes are zero.
10103            // Copy from the buffer into the object.
10104            unsafe {
10105                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10106            }
10107            Ok(())
10108        }
10109    }
10110
10111    impl fidl::encoding::ValueTypeMarker for AudioRendererPlayResponse {
10112        type Borrowed<'a> = &'a Self;
10113        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10114            value
10115        }
10116    }
10117
10118    unsafe impl fidl::encoding::TypeMarker for AudioRendererPlayResponse {
10119        type Owned = Self;
10120
10121        #[inline(always)]
10122        fn inline_align(_context: fidl::encoding::Context) -> usize {
10123            8
10124        }
10125
10126        #[inline(always)]
10127        fn inline_size(_context: fidl::encoding::Context) -> usize {
10128            16
10129        }
10130        #[inline(always)]
10131        fn encode_is_copy() -> bool {
10132            true
10133        }
10134
10135        #[inline(always)]
10136        fn decode_is_copy() -> bool {
10137            true
10138        }
10139    }
10140
10141    unsafe impl<D: fidl::encoding::ResourceDialect>
10142        fidl::encoding::Encode<AudioRendererPlayResponse, D> for &AudioRendererPlayResponse
10143    {
10144        #[inline]
10145        unsafe fn encode(
10146            self,
10147            encoder: &mut fidl::encoding::Encoder<'_, D>,
10148            offset: usize,
10149            _depth: fidl::encoding::Depth,
10150        ) -> fidl::Result<()> {
10151            encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
10152            unsafe {
10153                // Copy the object into the buffer.
10154                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10155                (buf_ptr as *mut AudioRendererPlayResponse)
10156                    .write_unaligned((self as *const AudioRendererPlayResponse).read());
10157                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10158                // done second because the memcpy will write garbage to these bytes.
10159            }
10160            Ok(())
10161        }
10162    }
10163    unsafe impl<
10164            D: fidl::encoding::ResourceDialect,
10165            T0: fidl::encoding::Encode<i64, D>,
10166            T1: fidl::encoding::Encode<i64, D>,
10167        > fidl::encoding::Encode<AudioRendererPlayResponse, D> for (T0, T1)
10168    {
10169        #[inline]
10170        unsafe fn encode(
10171            self,
10172            encoder: &mut fidl::encoding::Encoder<'_, D>,
10173            offset: usize,
10174            depth: fidl::encoding::Depth,
10175        ) -> fidl::Result<()> {
10176            encoder.debug_check_bounds::<AudioRendererPlayResponse>(offset);
10177            // Zero out padding regions. There's no need to apply masks
10178            // because the unmasked parts will be overwritten by fields.
10179            // Write the fields.
10180            self.0.encode(encoder, offset + 0, depth)?;
10181            self.1.encode(encoder, offset + 8, depth)?;
10182            Ok(())
10183        }
10184    }
10185
10186    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10187        for AudioRendererPlayResponse
10188    {
10189        #[inline(always)]
10190        fn new_empty() -> Self {
10191            Self { reference_time: fidl::new_empty!(i64, D), media_time: fidl::new_empty!(i64, D) }
10192        }
10193
10194        #[inline]
10195        unsafe fn decode(
10196            &mut self,
10197            decoder: &mut fidl::encoding::Decoder<'_, D>,
10198            offset: usize,
10199            _depth: fidl::encoding::Depth,
10200        ) -> fidl::Result<()> {
10201            decoder.debug_check_bounds::<Self>(offset);
10202            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10203            // Verify that padding bytes are zero.
10204            // Copy from the buffer into the object.
10205            unsafe {
10206                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
10207            }
10208            Ok(())
10209        }
10210    }
10211
10212    impl fidl::encoding::ValueTypeMarker for AudioRendererSetPcmStreamTypeRequest {
10213        type Borrowed<'a> = &'a Self;
10214        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10215            value
10216        }
10217    }
10218
10219    unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPcmStreamTypeRequest {
10220        type Owned = Self;
10221
10222        #[inline(always)]
10223        fn inline_align(_context: fidl::encoding::Context) -> usize {
10224            4
10225        }
10226
10227        #[inline(always)]
10228        fn inline_size(_context: fidl::encoding::Context) -> usize {
10229            12
10230        }
10231    }
10232
10233    unsafe impl<D: fidl::encoding::ResourceDialect>
10234        fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D>
10235        for &AudioRendererSetPcmStreamTypeRequest
10236    {
10237        #[inline]
10238        unsafe fn encode(
10239            self,
10240            encoder: &mut fidl::encoding::Encoder<'_, D>,
10241            offset: usize,
10242            _depth: fidl::encoding::Depth,
10243        ) -> fidl::Result<()> {
10244            encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10245            // Delegate to tuple encoding.
10246            fidl::encoding::Encode::<AudioRendererSetPcmStreamTypeRequest, D>::encode(
10247                (<AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
10248                encoder,
10249                offset,
10250                _depth,
10251            )
10252        }
10253    }
10254    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioStreamType, D>>
10255        fidl::encoding::Encode<AudioRendererSetPcmStreamTypeRequest, D> for (T0,)
10256    {
10257        #[inline]
10258        unsafe fn encode(
10259            self,
10260            encoder: &mut fidl::encoding::Encoder<'_, D>,
10261            offset: usize,
10262            depth: fidl::encoding::Depth,
10263        ) -> fidl::Result<()> {
10264            encoder.debug_check_bounds::<AudioRendererSetPcmStreamTypeRequest>(offset);
10265            // Zero out padding regions. There's no need to apply masks
10266            // because the unmasked parts will be overwritten by fields.
10267            // Write the fields.
10268            self.0.encode(encoder, offset + 0, depth)?;
10269            Ok(())
10270        }
10271    }
10272
10273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10274        for AudioRendererSetPcmStreamTypeRequest
10275    {
10276        #[inline(always)]
10277        fn new_empty() -> Self {
10278            Self { type_: fidl::new_empty!(AudioStreamType, D) }
10279        }
10280
10281        #[inline]
10282        unsafe fn decode(
10283            &mut self,
10284            decoder: &mut fidl::encoding::Decoder<'_, D>,
10285            offset: usize,
10286            _depth: fidl::encoding::Depth,
10287        ) -> fidl::Result<()> {
10288            decoder.debug_check_bounds::<Self>(offset);
10289            // Verify that padding bytes are zero.
10290            fidl::decode!(AudioStreamType, D, &mut self.type_, decoder, offset + 0, _depth)?;
10291            Ok(())
10292        }
10293    }
10294
10295    impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10296        type Borrowed<'a> = &'a Self;
10297        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10298            value
10299        }
10300    }
10301
10302    unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsContinuityThresholdRequest {
10303        type Owned = Self;
10304
10305        #[inline(always)]
10306        fn inline_align(_context: fidl::encoding::Context) -> usize {
10307            4
10308        }
10309
10310        #[inline(always)]
10311        fn inline_size(_context: fidl::encoding::Context) -> usize {
10312            4
10313        }
10314    }
10315
10316    unsafe impl<D: fidl::encoding::ResourceDialect>
10317        fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D>
10318        for &AudioRendererSetPtsContinuityThresholdRequest
10319    {
10320        #[inline]
10321        unsafe fn encode(
10322            self,
10323            encoder: &mut fidl::encoding::Encoder<'_, D>,
10324            offset: usize,
10325            _depth: fidl::encoding::Depth,
10326        ) -> fidl::Result<()> {
10327            encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10328            // Delegate to tuple encoding.
10329            fidl::encoding::Encode::<AudioRendererSetPtsContinuityThresholdRequest, D>::encode(
10330                (<f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.threshold_seconds),),
10331                encoder,
10332                offset,
10333                _depth,
10334            )
10335        }
10336    }
10337    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<f32, D>>
10338        fidl::encoding::Encode<AudioRendererSetPtsContinuityThresholdRequest, D> for (T0,)
10339    {
10340        #[inline]
10341        unsafe fn encode(
10342            self,
10343            encoder: &mut fidl::encoding::Encoder<'_, D>,
10344            offset: usize,
10345            depth: fidl::encoding::Depth,
10346        ) -> fidl::Result<()> {
10347            encoder.debug_check_bounds::<AudioRendererSetPtsContinuityThresholdRequest>(offset);
10348            // Zero out padding regions. There's no need to apply masks
10349            // because the unmasked parts will be overwritten by fields.
10350            // Write the fields.
10351            self.0.encode(encoder, offset + 0, depth)?;
10352            Ok(())
10353        }
10354    }
10355
10356    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10357        for AudioRendererSetPtsContinuityThresholdRequest
10358    {
10359        #[inline(always)]
10360        fn new_empty() -> Self {
10361            Self { threshold_seconds: fidl::new_empty!(f32, D) }
10362        }
10363
10364        #[inline]
10365        unsafe fn decode(
10366            &mut self,
10367            decoder: &mut fidl::encoding::Decoder<'_, D>,
10368            offset: usize,
10369            _depth: fidl::encoding::Depth,
10370        ) -> fidl::Result<()> {
10371            decoder.debug_check_bounds::<Self>(offset);
10372            // Verify that padding bytes are zero.
10373            fidl::decode!(f32, D, &mut self.threshold_seconds, decoder, offset + 0, _depth)?;
10374            Ok(())
10375        }
10376    }
10377
10378    impl fidl::encoding::ValueTypeMarker for AudioRendererSetPtsUnitsRequest {
10379        type Borrowed<'a> = &'a Self;
10380        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10381            value
10382        }
10383    }
10384
10385    unsafe impl fidl::encoding::TypeMarker for AudioRendererSetPtsUnitsRequest {
10386        type Owned = Self;
10387
10388        #[inline(always)]
10389        fn inline_align(_context: fidl::encoding::Context) -> usize {
10390            4
10391        }
10392
10393        #[inline(always)]
10394        fn inline_size(_context: fidl::encoding::Context) -> usize {
10395            8
10396        }
10397        #[inline(always)]
10398        fn encode_is_copy() -> bool {
10399            true
10400        }
10401
10402        #[inline(always)]
10403        fn decode_is_copy() -> bool {
10404            true
10405        }
10406    }
10407
10408    unsafe impl<D: fidl::encoding::ResourceDialect>
10409        fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D>
10410        for &AudioRendererSetPtsUnitsRequest
10411    {
10412        #[inline]
10413        unsafe fn encode(
10414            self,
10415            encoder: &mut fidl::encoding::Encoder<'_, D>,
10416            offset: usize,
10417            _depth: fidl::encoding::Depth,
10418        ) -> fidl::Result<()> {
10419            encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10420            unsafe {
10421                // Copy the object into the buffer.
10422                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10423                (buf_ptr as *mut AudioRendererSetPtsUnitsRequest)
10424                    .write_unaligned((self as *const AudioRendererSetPtsUnitsRequest).read());
10425                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10426                // done second because the memcpy will write garbage to these bytes.
10427            }
10428            Ok(())
10429        }
10430    }
10431    unsafe impl<
10432            D: fidl::encoding::ResourceDialect,
10433            T0: fidl::encoding::Encode<u32, D>,
10434            T1: fidl::encoding::Encode<u32, D>,
10435        > fidl::encoding::Encode<AudioRendererSetPtsUnitsRequest, D> for (T0, T1)
10436    {
10437        #[inline]
10438        unsafe fn encode(
10439            self,
10440            encoder: &mut fidl::encoding::Encoder<'_, D>,
10441            offset: usize,
10442            depth: fidl::encoding::Depth,
10443        ) -> fidl::Result<()> {
10444            encoder.debug_check_bounds::<AudioRendererSetPtsUnitsRequest>(offset);
10445            // Zero out padding regions. There's no need to apply masks
10446            // because the unmasked parts will be overwritten by fields.
10447            // Write the fields.
10448            self.0.encode(encoder, offset + 0, depth)?;
10449            self.1.encode(encoder, offset + 4, depth)?;
10450            Ok(())
10451        }
10452    }
10453
10454    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10455        for AudioRendererSetPtsUnitsRequest
10456    {
10457        #[inline(always)]
10458        fn new_empty() -> Self {
10459            Self {
10460                tick_per_second_numerator: fidl::new_empty!(u32, D),
10461                tick_per_second_denominator: fidl::new_empty!(u32, D),
10462            }
10463        }
10464
10465        #[inline]
10466        unsafe fn decode(
10467            &mut self,
10468            decoder: &mut fidl::encoding::Decoder<'_, D>,
10469            offset: usize,
10470            _depth: fidl::encoding::Depth,
10471        ) -> fidl::Result<()> {
10472            decoder.debug_check_bounds::<Self>(offset);
10473            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10474            // Verify that padding bytes are zero.
10475            // Copy from the buffer into the object.
10476            unsafe {
10477                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10478            }
10479            Ok(())
10480        }
10481    }
10482
10483    impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsage2Request {
10484        type Borrowed<'a> = &'a Self;
10485        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10486            value
10487        }
10488    }
10489
10490    unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsage2Request {
10491        type Owned = Self;
10492
10493        #[inline(always)]
10494        fn inline_align(_context: fidl::encoding::Context) -> usize {
10495            4
10496        }
10497
10498        #[inline(always)]
10499        fn inline_size(_context: fidl::encoding::Context) -> usize {
10500            4
10501        }
10502    }
10503
10504    unsafe impl<D: fidl::encoding::ResourceDialect>
10505        fidl::encoding::Encode<AudioRendererSetUsage2Request, D>
10506        for &AudioRendererSetUsage2Request
10507    {
10508        #[inline]
10509        unsafe fn encode(
10510            self,
10511            encoder: &mut fidl::encoding::Encoder<'_, D>,
10512            offset: usize,
10513            _depth: fidl::encoding::Depth,
10514        ) -> fidl::Result<()> {
10515            encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10516            // Delegate to tuple encoding.
10517            fidl::encoding::Encode::<AudioRendererSetUsage2Request, D>::encode(
10518                (<AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage2),),
10519                encoder,
10520                offset,
10521                _depth,
10522            )
10523        }
10524    }
10525    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage2, D>>
10526        fidl::encoding::Encode<AudioRendererSetUsage2Request, D> for (T0,)
10527    {
10528        #[inline]
10529        unsafe fn encode(
10530            self,
10531            encoder: &mut fidl::encoding::Encoder<'_, D>,
10532            offset: usize,
10533            depth: fidl::encoding::Depth,
10534        ) -> fidl::Result<()> {
10535            encoder.debug_check_bounds::<AudioRendererSetUsage2Request>(offset);
10536            // Zero out padding regions. There's no need to apply masks
10537            // because the unmasked parts will be overwritten by fields.
10538            // Write the fields.
10539            self.0.encode(encoder, offset + 0, depth)?;
10540            Ok(())
10541        }
10542    }
10543
10544    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10545        for AudioRendererSetUsage2Request
10546    {
10547        #[inline(always)]
10548        fn new_empty() -> Self {
10549            Self { usage2: fidl::new_empty!(AudioRenderUsage2, D) }
10550        }
10551
10552        #[inline]
10553        unsafe fn decode(
10554            &mut self,
10555            decoder: &mut fidl::encoding::Decoder<'_, D>,
10556            offset: usize,
10557            _depth: fidl::encoding::Depth,
10558        ) -> fidl::Result<()> {
10559            decoder.debug_check_bounds::<Self>(offset);
10560            // Verify that padding bytes are zero.
10561            fidl::decode!(AudioRenderUsage2, D, &mut self.usage2, decoder, offset + 0, _depth)?;
10562            Ok(())
10563        }
10564    }
10565
10566    impl fidl::encoding::ValueTypeMarker for AudioRendererSetUsageRequest {
10567        type Borrowed<'a> = &'a Self;
10568        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10569            value
10570        }
10571    }
10572
10573    unsafe impl fidl::encoding::TypeMarker for AudioRendererSetUsageRequest {
10574        type Owned = Self;
10575
10576        #[inline(always)]
10577        fn inline_align(_context: fidl::encoding::Context) -> usize {
10578            4
10579        }
10580
10581        #[inline(always)]
10582        fn inline_size(_context: fidl::encoding::Context) -> usize {
10583            4
10584        }
10585    }
10586
10587    unsafe impl<D: fidl::encoding::ResourceDialect>
10588        fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for &AudioRendererSetUsageRequest
10589    {
10590        #[inline]
10591        unsafe fn encode(
10592            self,
10593            encoder: &mut fidl::encoding::Encoder<'_, D>,
10594            offset: usize,
10595            _depth: fidl::encoding::Depth,
10596        ) -> fidl::Result<()> {
10597            encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10598            // Delegate to tuple encoding.
10599            fidl::encoding::Encode::<AudioRendererSetUsageRequest, D>::encode(
10600                (<AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),),
10601                encoder,
10602                offset,
10603                _depth,
10604            )
10605        }
10606    }
10607    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AudioRenderUsage, D>>
10608        fidl::encoding::Encode<AudioRendererSetUsageRequest, D> for (T0,)
10609    {
10610        #[inline]
10611        unsafe fn encode(
10612            self,
10613            encoder: &mut fidl::encoding::Encoder<'_, D>,
10614            offset: usize,
10615            depth: fidl::encoding::Depth,
10616        ) -> fidl::Result<()> {
10617            encoder.debug_check_bounds::<AudioRendererSetUsageRequest>(offset);
10618            // Zero out padding regions. There's no need to apply masks
10619            // because the unmasked parts will be overwritten by fields.
10620            // Write the fields.
10621            self.0.encode(encoder, offset + 0, depth)?;
10622            Ok(())
10623        }
10624    }
10625
10626    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10627        for AudioRendererSetUsageRequest
10628    {
10629        #[inline(always)]
10630        fn new_empty() -> Self {
10631            Self { usage: fidl::new_empty!(AudioRenderUsage, D) }
10632        }
10633
10634        #[inline]
10635        unsafe fn decode(
10636            &mut self,
10637            decoder: &mut fidl::encoding::Decoder<'_, D>,
10638            offset: usize,
10639            _depth: fidl::encoding::Depth,
10640        ) -> fidl::Result<()> {
10641            decoder.debug_check_bounds::<Self>(offset);
10642            // Verify that padding bytes are zero.
10643            fidl::decode!(AudioRenderUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
10644            Ok(())
10645        }
10646    }
10647
10648    impl fidl::encoding::ValueTypeMarker for AudioStreamType {
10649        type Borrowed<'a> = &'a Self;
10650        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10651            value
10652        }
10653    }
10654
10655    unsafe impl fidl::encoding::TypeMarker for AudioStreamType {
10656        type Owned = Self;
10657
10658        #[inline(always)]
10659        fn inline_align(_context: fidl::encoding::Context) -> usize {
10660            4
10661        }
10662
10663        #[inline(always)]
10664        fn inline_size(_context: fidl::encoding::Context) -> usize {
10665            12
10666        }
10667    }
10668
10669    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioStreamType, D>
10670        for &AudioStreamType
10671    {
10672        #[inline]
10673        unsafe fn encode(
10674            self,
10675            encoder: &mut fidl::encoding::Encoder<'_, D>,
10676            offset: usize,
10677            _depth: fidl::encoding::Depth,
10678        ) -> fidl::Result<()> {
10679            encoder.debug_check_bounds::<AudioStreamType>(offset);
10680            // Delegate to tuple encoding.
10681            fidl::encoding::Encode::<AudioStreamType, D>::encode(
10682                (
10683                    <AudioSampleFormat as fidl::encoding::ValueTypeMarker>::borrow(
10684                        &self.sample_format,
10685                    ),
10686                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.channels),
10687                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
10688                ),
10689                encoder,
10690                offset,
10691                _depth,
10692            )
10693        }
10694    }
10695    unsafe impl<
10696            D: fidl::encoding::ResourceDialect,
10697            T0: fidl::encoding::Encode<AudioSampleFormat, D>,
10698            T1: fidl::encoding::Encode<u32, D>,
10699            T2: fidl::encoding::Encode<u32, D>,
10700        > fidl::encoding::Encode<AudioStreamType, D> for (T0, T1, T2)
10701    {
10702        #[inline]
10703        unsafe fn encode(
10704            self,
10705            encoder: &mut fidl::encoding::Encoder<'_, D>,
10706            offset: usize,
10707            depth: fidl::encoding::Depth,
10708        ) -> fidl::Result<()> {
10709            encoder.debug_check_bounds::<AudioStreamType>(offset);
10710            // Zero out padding regions. There's no need to apply masks
10711            // because the unmasked parts will be overwritten by fields.
10712            // Write the fields.
10713            self.0.encode(encoder, offset + 0, depth)?;
10714            self.1.encode(encoder, offset + 4, depth)?;
10715            self.2.encode(encoder, offset + 8, depth)?;
10716            Ok(())
10717        }
10718    }
10719
10720    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioStreamType {
10721        #[inline(always)]
10722        fn new_empty() -> Self {
10723            Self {
10724                sample_format: fidl::new_empty!(AudioSampleFormat, D),
10725                channels: fidl::new_empty!(u32, D),
10726                frames_per_second: fidl::new_empty!(u32, D),
10727            }
10728        }
10729
10730        #[inline]
10731        unsafe fn decode(
10732            &mut self,
10733            decoder: &mut fidl::encoding::Decoder<'_, D>,
10734            offset: usize,
10735            _depth: fidl::encoding::Depth,
10736        ) -> fidl::Result<()> {
10737            decoder.debug_check_bounds::<Self>(offset);
10738            // Verify that padding bytes are zero.
10739            fidl::decode!(
10740                AudioSampleFormat,
10741                D,
10742                &mut self.sample_format,
10743                decoder,
10744                offset + 0,
10745                _depth
10746            )?;
10747            fidl::decode!(u32, D, &mut self.channels, decoder, offset + 4, _depth)?;
10748            fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
10749            Ok(())
10750        }
10751    }
10752
10753    impl fidl::encoding::ValueTypeMarker for Compression {
10754        type Borrowed<'a> = &'a Self;
10755        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10756            value
10757        }
10758    }
10759
10760    unsafe impl fidl::encoding::TypeMarker for Compression {
10761        type Owned = Self;
10762
10763        #[inline(always)]
10764        fn inline_align(_context: fidl::encoding::Context) -> usize {
10765            8
10766        }
10767
10768        #[inline(always)]
10769        fn inline_size(_context: fidl::encoding::Context) -> usize {
10770            32
10771        }
10772    }
10773
10774    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Compression, D>
10775        for &Compression
10776    {
10777        #[inline]
10778        unsafe fn encode(
10779            self,
10780            encoder: &mut fidl::encoding::Encoder<'_, D>,
10781            offset: usize,
10782            _depth: fidl::encoding::Depth,
10783        ) -> fidl::Result<()> {
10784            encoder.debug_check_bounds::<Compression>(offset);
10785            // Delegate to tuple encoding.
10786            fidl::encoding::Encode::<Compression, D>::encode(
10787                (
10788                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
10789                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
10790                ),
10791                encoder, offset, _depth
10792            )
10793        }
10794    }
10795    unsafe impl<
10796            D: fidl::encoding::ResourceDialect,
10797            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
10798            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>, D>,
10799        > fidl::encoding::Encode<Compression, D> for (T0, T1)
10800    {
10801        #[inline]
10802        unsafe fn encode(
10803            self,
10804            encoder: &mut fidl::encoding::Encoder<'_, D>,
10805            offset: usize,
10806            depth: fidl::encoding::Depth,
10807        ) -> fidl::Result<()> {
10808            encoder.debug_check_bounds::<Compression>(offset);
10809            // Zero out padding regions. There's no need to apply masks
10810            // because the unmasked parts will be overwritten by fields.
10811            // Write the fields.
10812            self.0.encode(encoder, offset + 0, depth)?;
10813            self.1.encode(encoder, offset + 16, depth)?;
10814            Ok(())
10815        }
10816    }
10817
10818    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Compression {
10819        #[inline(always)]
10820        fn new_empty() -> Self {
10821            Self {
10822                type_: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
10823                parameters: fidl::new_empty!(
10824                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10825                    D
10826                ),
10827            }
10828        }
10829
10830        #[inline]
10831        unsafe fn decode(
10832            &mut self,
10833            decoder: &mut fidl::encoding::Decoder<'_, D>,
10834            offset: usize,
10835            _depth: fidl::encoding::Depth,
10836        ) -> fidl::Result<()> {
10837            decoder.debug_check_bounds::<Self>(offset);
10838            // Verify that padding bytes are zero.
10839            fidl::decode!(
10840                fidl::encoding::BoundedString<256>,
10841                D,
10842                &mut self.type_,
10843                decoder,
10844                offset + 0,
10845                _depth
10846            )?;
10847            fidl::decode!(
10848                fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
10849                D,
10850                &mut self.parameters,
10851                decoder,
10852                offset + 16,
10853                _depth
10854            )?;
10855            Ok(())
10856        }
10857    }
10858
10859    impl fidl::encoding::ValueTypeMarker for EncryptionPattern {
10860        type Borrowed<'a> = &'a Self;
10861        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10862            value
10863        }
10864    }
10865
10866    unsafe impl fidl::encoding::TypeMarker for EncryptionPattern {
10867        type Owned = Self;
10868
10869        #[inline(always)]
10870        fn inline_align(_context: fidl::encoding::Context) -> usize {
10871            4
10872        }
10873
10874        #[inline(always)]
10875        fn inline_size(_context: fidl::encoding::Context) -> usize {
10876            8
10877        }
10878        #[inline(always)]
10879        fn encode_is_copy() -> bool {
10880            true
10881        }
10882
10883        #[inline(always)]
10884        fn decode_is_copy() -> bool {
10885            true
10886        }
10887    }
10888
10889    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptionPattern, D>
10890        for &EncryptionPattern
10891    {
10892        #[inline]
10893        unsafe fn encode(
10894            self,
10895            encoder: &mut fidl::encoding::Encoder<'_, D>,
10896            offset: usize,
10897            _depth: fidl::encoding::Depth,
10898        ) -> fidl::Result<()> {
10899            encoder.debug_check_bounds::<EncryptionPattern>(offset);
10900            unsafe {
10901                // Copy the object into the buffer.
10902                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10903                (buf_ptr as *mut EncryptionPattern)
10904                    .write_unaligned((self as *const EncryptionPattern).read());
10905                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10906                // done second because the memcpy will write garbage to these bytes.
10907            }
10908            Ok(())
10909        }
10910    }
10911    unsafe impl<
10912            D: fidl::encoding::ResourceDialect,
10913            T0: fidl::encoding::Encode<u32, D>,
10914            T1: fidl::encoding::Encode<u32, D>,
10915        > fidl::encoding::Encode<EncryptionPattern, D> for (T0, T1)
10916    {
10917        #[inline]
10918        unsafe fn encode(
10919            self,
10920            encoder: &mut fidl::encoding::Encoder<'_, D>,
10921            offset: usize,
10922            depth: fidl::encoding::Depth,
10923        ) -> fidl::Result<()> {
10924            encoder.debug_check_bounds::<EncryptionPattern>(offset);
10925            // Zero out padding regions. There's no need to apply masks
10926            // because the unmasked parts will be overwritten by fields.
10927            // Write the fields.
10928            self.0.encode(encoder, offset + 0, depth)?;
10929            self.1.encode(encoder, offset + 4, depth)?;
10930            Ok(())
10931        }
10932    }
10933
10934    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptionPattern {
10935        #[inline(always)]
10936        fn new_empty() -> Self {
10937            Self {
10938                clear_blocks: fidl::new_empty!(u32, D),
10939                encrypted_blocks: fidl::new_empty!(u32, D),
10940            }
10941        }
10942
10943        #[inline]
10944        unsafe fn decode(
10945            &mut self,
10946            decoder: &mut fidl::encoding::Decoder<'_, D>,
10947            offset: usize,
10948            _depth: fidl::encoding::Depth,
10949        ) -> fidl::Result<()> {
10950            decoder.debug_check_bounds::<Self>(offset);
10951            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10952            // Verify that padding bytes are zero.
10953            // Copy from the buffer into the object.
10954            unsafe {
10955                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10956            }
10957            Ok(())
10958        }
10959    }
10960
10961    impl fidl::encoding::ValueTypeMarker for Metadata {
10962        type Borrowed<'a> = &'a Self;
10963        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10964            value
10965        }
10966    }
10967
10968    unsafe impl fidl::encoding::TypeMarker for Metadata {
10969        type Owned = Self;
10970
10971        #[inline(always)]
10972        fn inline_align(_context: fidl::encoding::Context) -> usize {
10973            8
10974        }
10975
10976        #[inline(always)]
10977        fn inline_size(_context: fidl::encoding::Context) -> usize {
10978            16
10979        }
10980    }
10981
10982    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metadata, D> for &Metadata {
10983        #[inline]
10984        unsafe fn encode(
10985            self,
10986            encoder: &mut fidl::encoding::Encoder<'_, D>,
10987            offset: usize,
10988            _depth: fidl::encoding::Depth,
10989        ) -> fidl::Result<()> {
10990            encoder.debug_check_bounds::<Metadata>(offset);
10991            // Delegate to tuple encoding.
10992            fidl::encoding::Encode::<Metadata, D>::encode(
10993                (
10994                    <fidl::encoding::UnboundedVector<Property> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
10995                ),
10996                encoder, offset, _depth
10997            )
10998        }
10999    }
11000    unsafe impl<
11001            D: fidl::encoding::ResourceDialect,
11002            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Property>, D>,
11003        > fidl::encoding::Encode<Metadata, D> for (T0,)
11004    {
11005        #[inline]
11006        unsafe fn encode(
11007            self,
11008            encoder: &mut fidl::encoding::Encoder<'_, D>,
11009            offset: usize,
11010            depth: fidl::encoding::Depth,
11011        ) -> fidl::Result<()> {
11012            encoder.debug_check_bounds::<Metadata>(offset);
11013            // Zero out padding regions. There's no need to apply masks
11014            // because the unmasked parts will be overwritten by fields.
11015            // Write the fields.
11016            self.0.encode(encoder, offset + 0, depth)?;
11017            Ok(())
11018        }
11019    }
11020
11021    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metadata {
11022        #[inline(always)]
11023        fn new_empty() -> Self {
11024            Self { properties: fidl::new_empty!(fidl::encoding::UnboundedVector<Property>, D) }
11025        }
11026
11027        #[inline]
11028        unsafe fn decode(
11029            &mut self,
11030            decoder: &mut fidl::encoding::Decoder<'_, D>,
11031            offset: usize,
11032            _depth: fidl::encoding::Depth,
11033        ) -> fidl::Result<()> {
11034            decoder.debug_check_bounds::<Self>(offset);
11035            // Verify that padding bytes are zero.
11036            fidl::decode!(
11037                fidl::encoding::UnboundedVector<Property>,
11038                D,
11039                &mut self.properties,
11040                decoder,
11041                offset + 0,
11042                _depth
11043            )?;
11044            Ok(())
11045        }
11046    }
11047
11048    impl fidl::encoding::ValueTypeMarker for Parameter {
11049        type Borrowed<'a> = &'a Self;
11050        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11051            value
11052        }
11053    }
11054
11055    unsafe impl fidl::encoding::TypeMarker for Parameter {
11056        type Owned = Self;
11057
11058        #[inline(always)]
11059        fn inline_align(_context: fidl::encoding::Context) -> usize {
11060            8
11061        }
11062
11063        #[inline(always)]
11064        fn inline_size(_context: fidl::encoding::Context) -> usize {
11065            48
11066        }
11067    }
11068
11069    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
11070        for &Parameter
11071    {
11072        #[inline]
11073        unsafe fn encode(
11074            self,
11075            encoder: &mut fidl::encoding::Encoder<'_, D>,
11076            offset: usize,
11077            _depth: fidl::encoding::Depth,
11078        ) -> fidl::Result<()> {
11079            encoder.debug_check_bounds::<Parameter>(offset);
11080            // Delegate to tuple encoding.
11081            fidl::encoding::Encode::<Parameter, D>::encode(
11082                (
11083                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11084                        &self.scope,
11085                    ),
11086                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11087                        &self.name,
11088                    ),
11089                    <Value as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
11090                ),
11091                encoder,
11092                offset,
11093                _depth,
11094            )
11095        }
11096    }
11097    unsafe impl<
11098            D: fidl::encoding::ResourceDialect,
11099            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11100            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11101            T2: fidl::encoding::Encode<Value, D>,
11102        > fidl::encoding::Encode<Parameter, D> for (T0, T1, T2)
11103    {
11104        #[inline]
11105        unsafe fn encode(
11106            self,
11107            encoder: &mut fidl::encoding::Encoder<'_, D>,
11108            offset: usize,
11109            depth: fidl::encoding::Depth,
11110        ) -> fidl::Result<()> {
11111            encoder.debug_check_bounds::<Parameter>(offset);
11112            // Zero out padding regions. There's no need to apply masks
11113            // because the unmasked parts will be overwritten by fields.
11114            // Write the fields.
11115            self.0.encode(encoder, offset + 0, depth)?;
11116            self.1.encode(encoder, offset + 16, depth)?;
11117            self.2.encode(encoder, offset + 32, depth)?;
11118            Ok(())
11119        }
11120    }
11121
11122    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
11123        #[inline(always)]
11124        fn new_empty() -> Self {
11125            Self {
11126                scope: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11127                name: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11128                value: fidl::new_empty!(Value, D),
11129            }
11130        }
11131
11132        #[inline]
11133        unsafe fn decode(
11134            &mut self,
11135            decoder: &mut fidl::encoding::Decoder<'_, D>,
11136            offset: usize,
11137            _depth: fidl::encoding::Depth,
11138        ) -> fidl::Result<()> {
11139            decoder.debug_check_bounds::<Self>(offset);
11140            // Verify that padding bytes are zero.
11141            fidl::decode!(
11142                fidl::encoding::UnboundedString,
11143                D,
11144                &mut self.scope,
11145                decoder,
11146                offset + 0,
11147                _depth
11148            )?;
11149            fidl::decode!(
11150                fidl::encoding::UnboundedString,
11151                D,
11152                &mut self.name,
11153                decoder,
11154                offset + 16,
11155                _depth
11156            )?;
11157            fidl::decode!(Value, D, &mut self.value, decoder, offset + 32, _depth)?;
11158            Ok(())
11159        }
11160    }
11161
11162    impl fidl::encoding::ValueTypeMarker for PcmFormat {
11163        type Borrowed<'a> = &'a Self;
11164        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11165            value
11166        }
11167    }
11168
11169    unsafe impl fidl::encoding::TypeMarker for PcmFormat {
11170        type Owned = Self;
11171
11172        #[inline(always)]
11173        fn inline_align(_context: fidl::encoding::Context) -> usize {
11174            8
11175        }
11176
11177        #[inline(always)]
11178        fn inline_size(_context: fidl::encoding::Context) -> usize {
11179            32
11180        }
11181    }
11182
11183    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormat, D>
11184        for &PcmFormat
11185    {
11186        #[inline]
11187        unsafe fn encode(
11188            self,
11189            encoder: &mut fidl::encoding::Encoder<'_, D>,
11190            offset: usize,
11191            _depth: fidl::encoding::Depth,
11192        ) -> fidl::Result<()> {
11193            encoder.debug_check_bounds::<PcmFormat>(offset);
11194            // Delegate to tuple encoding.
11195            fidl::encoding::Encode::<PcmFormat, D>::encode(
11196                (
11197                    <AudioPcmMode as fidl::encoding::ValueTypeMarker>::borrow(&self.pcm_mode),
11198                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.bits_per_sample),
11199                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.frames_per_second),
11200                    <fidl::encoding::Vector<AudioChannelId, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_map),
11201                ),
11202                encoder, offset, _depth
11203            )
11204        }
11205    }
11206    unsafe impl<
11207            D: fidl::encoding::ResourceDialect,
11208            T0: fidl::encoding::Encode<AudioPcmMode, D>,
11209            T1: fidl::encoding::Encode<u32, D>,
11210            T2: fidl::encoding::Encode<u32, D>,
11211            T3: fidl::encoding::Encode<fidl::encoding::Vector<AudioChannelId, 16>, D>,
11212        > fidl::encoding::Encode<PcmFormat, D> for (T0, T1, T2, T3)
11213    {
11214        #[inline]
11215        unsafe fn encode(
11216            self,
11217            encoder: &mut fidl::encoding::Encoder<'_, D>,
11218            offset: usize,
11219            depth: fidl::encoding::Depth,
11220        ) -> fidl::Result<()> {
11221            encoder.debug_check_bounds::<PcmFormat>(offset);
11222            // Zero out padding regions. There's no need to apply masks
11223            // because the unmasked parts will be overwritten by fields.
11224            unsafe {
11225                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11226                (ptr as *mut u64).write_unaligned(0);
11227            }
11228            // Write the fields.
11229            self.0.encode(encoder, offset + 0, depth)?;
11230            self.1.encode(encoder, offset + 4, depth)?;
11231            self.2.encode(encoder, offset + 8, depth)?;
11232            self.3.encode(encoder, offset + 16, depth)?;
11233            Ok(())
11234        }
11235    }
11236
11237    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormat {
11238        #[inline(always)]
11239        fn new_empty() -> Self {
11240            Self {
11241                pcm_mode: fidl::new_empty!(AudioPcmMode, D),
11242                bits_per_sample: fidl::new_empty!(u32, D),
11243                frames_per_second: fidl::new_empty!(u32, D),
11244                channel_map: fidl::new_empty!(fidl::encoding::Vector<AudioChannelId, 16>, D),
11245            }
11246        }
11247
11248        #[inline]
11249        unsafe fn decode(
11250            &mut self,
11251            decoder: &mut fidl::encoding::Decoder<'_, D>,
11252            offset: usize,
11253            _depth: fidl::encoding::Depth,
11254        ) -> fidl::Result<()> {
11255            decoder.debug_check_bounds::<Self>(offset);
11256            // Verify that padding bytes are zero.
11257            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11258            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11259            let mask = 0xffffffff00000000u64;
11260            let maskedval = padval & mask;
11261            if maskedval != 0 {
11262                return Err(fidl::Error::NonZeroPadding {
11263                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11264                });
11265            }
11266            fidl::decode!(AudioPcmMode, D, &mut self.pcm_mode, decoder, offset + 0, _depth)?;
11267            fidl::decode!(u32, D, &mut self.bits_per_sample, decoder, offset + 4, _depth)?;
11268            fidl::decode!(u32, D, &mut self.frames_per_second, decoder, offset + 8, _depth)?;
11269            fidl::decode!(fidl::encoding::Vector<AudioChannelId, 16>, D, &mut self.channel_map, decoder, offset + 16, _depth)?;
11270            Ok(())
11271        }
11272    }
11273
11274    impl fidl::encoding::ValueTypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11275        type Borrowed<'a> = &'a Self;
11276        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11277            value
11278        }
11279    }
11280
11281    unsafe impl fidl::encoding::TypeMarker for ProfileProviderRegisterHandlerWithCapacityResponse {
11282        type Owned = Self;
11283
11284        #[inline(always)]
11285        fn inline_align(_context: fidl::encoding::Context) -> usize {
11286            8
11287        }
11288
11289        #[inline(always)]
11290        fn inline_size(_context: fidl::encoding::Context) -> usize {
11291            16
11292        }
11293        #[inline(always)]
11294        fn encode_is_copy() -> bool {
11295            true
11296        }
11297
11298        #[inline(always)]
11299        fn decode_is_copy() -> bool {
11300            true
11301        }
11302    }
11303
11304    unsafe impl<D: fidl::encoding::ResourceDialect>
11305        fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11306        for &ProfileProviderRegisterHandlerWithCapacityResponse
11307    {
11308        #[inline]
11309        unsafe fn encode(
11310            self,
11311            encoder: &mut fidl::encoding::Encoder<'_, D>,
11312            offset: usize,
11313            _depth: fidl::encoding::Depth,
11314        ) -> fidl::Result<()> {
11315            encoder
11316                .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11317            unsafe {
11318                // Copy the object into the buffer.
11319                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11320                (buf_ptr as *mut ProfileProviderRegisterHandlerWithCapacityResponse)
11321                    .write_unaligned(
11322                        (self as *const ProfileProviderRegisterHandlerWithCapacityResponse).read(),
11323                    );
11324                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11325                // done second because the memcpy will write garbage to these bytes.
11326            }
11327            Ok(())
11328        }
11329    }
11330    unsafe impl<
11331            D: fidl::encoding::ResourceDialect,
11332            T0: fidl::encoding::Encode<i64, D>,
11333            T1: fidl::encoding::Encode<i64, D>,
11334        > fidl::encoding::Encode<ProfileProviderRegisterHandlerWithCapacityResponse, D>
11335        for (T0, T1)
11336    {
11337        #[inline]
11338        unsafe fn encode(
11339            self,
11340            encoder: &mut fidl::encoding::Encoder<'_, D>,
11341            offset: usize,
11342            depth: fidl::encoding::Depth,
11343        ) -> fidl::Result<()> {
11344            encoder
11345                .debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityResponse>(offset);
11346            // Zero out padding regions. There's no need to apply masks
11347            // because the unmasked parts will be overwritten by fields.
11348            // Write the fields.
11349            self.0.encode(encoder, offset + 0, depth)?;
11350            self.1.encode(encoder, offset + 8, depth)?;
11351            Ok(())
11352        }
11353    }
11354
11355    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11356        for ProfileProviderRegisterHandlerWithCapacityResponse
11357    {
11358        #[inline(always)]
11359        fn new_empty() -> Self {
11360            Self { period: fidl::new_empty!(i64, D), capacity: fidl::new_empty!(i64, D) }
11361        }
11362
11363        #[inline]
11364        unsafe fn decode(
11365            &mut self,
11366            decoder: &mut fidl::encoding::Decoder<'_, D>,
11367            offset: usize,
11368            _depth: fidl::encoding::Depth,
11369        ) -> fidl::Result<()> {
11370            decoder.debug_check_bounds::<Self>(offset);
11371            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11372            // Verify that padding bytes are zero.
11373            // Copy from the buffer into the object.
11374            unsafe {
11375                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
11376            }
11377            Ok(())
11378        }
11379    }
11380
11381    impl fidl::encoding::ValueTypeMarker for Property {
11382        type Borrowed<'a> = &'a Self;
11383        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11384            value
11385        }
11386    }
11387
11388    unsafe impl fidl::encoding::TypeMarker for Property {
11389        type Owned = Self;
11390
11391        #[inline(always)]
11392        fn inline_align(_context: fidl::encoding::Context) -> usize {
11393            8
11394        }
11395
11396        #[inline(always)]
11397        fn inline_size(_context: fidl::encoding::Context) -> usize {
11398            32
11399        }
11400    }
11401
11402    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Property, D> for &Property {
11403        #[inline]
11404        unsafe fn encode(
11405            self,
11406            encoder: &mut fidl::encoding::Encoder<'_, D>,
11407            offset: usize,
11408            _depth: fidl::encoding::Depth,
11409        ) -> fidl::Result<()> {
11410            encoder.debug_check_bounds::<Property>(offset);
11411            // Delegate to tuple encoding.
11412            fidl::encoding::Encode::<Property, D>::encode(
11413                (
11414                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11415                        &self.label,
11416                    ),
11417                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
11418                        &self.value,
11419                    ),
11420                ),
11421                encoder,
11422                offset,
11423                _depth,
11424            )
11425        }
11426    }
11427    unsafe impl<
11428            D: fidl::encoding::ResourceDialect,
11429            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11430            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
11431        > fidl::encoding::Encode<Property, D> for (T0, T1)
11432    {
11433        #[inline]
11434        unsafe fn encode(
11435            self,
11436            encoder: &mut fidl::encoding::Encoder<'_, D>,
11437            offset: usize,
11438            depth: fidl::encoding::Depth,
11439        ) -> fidl::Result<()> {
11440            encoder.debug_check_bounds::<Property>(offset);
11441            // Zero out padding regions. There's no need to apply masks
11442            // because the unmasked parts will be overwritten by fields.
11443            // Write the fields.
11444            self.0.encode(encoder, offset + 0, depth)?;
11445            self.1.encode(encoder, offset + 16, depth)?;
11446            Ok(())
11447        }
11448    }
11449
11450    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Property {
11451        #[inline(always)]
11452        fn new_empty() -> Self {
11453            Self {
11454                label: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11455                value: fidl::new_empty!(fidl::encoding::UnboundedString, D),
11456            }
11457        }
11458
11459        #[inline]
11460        unsafe fn decode(
11461            &mut self,
11462            decoder: &mut fidl::encoding::Decoder<'_, D>,
11463            offset: usize,
11464            _depth: fidl::encoding::Depth,
11465        ) -> fidl::Result<()> {
11466            decoder.debug_check_bounds::<Self>(offset);
11467            // Verify that padding bytes are zero.
11468            fidl::decode!(
11469                fidl::encoding::UnboundedString,
11470                D,
11471                &mut self.label,
11472                decoder,
11473                offset + 0,
11474                _depth
11475            )?;
11476            fidl::decode!(
11477                fidl::encoding::UnboundedString,
11478                D,
11479                &mut self.value,
11480                decoder,
11481                offset + 16,
11482                _depth
11483            )?;
11484            Ok(())
11485        }
11486    }
11487
11488    impl fidl::encoding::ValueTypeMarker for SbcEncoderSettings {
11489        type Borrowed<'a> = &'a Self;
11490        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11491            value
11492        }
11493    }
11494
11495    unsafe impl fidl::encoding::TypeMarker for SbcEncoderSettings {
11496        type Owned = Self;
11497
11498        #[inline(always)]
11499        fn inline_align(_context: fidl::encoding::Context) -> usize {
11500            8
11501        }
11502
11503        #[inline(always)]
11504        fn inline_size(_context: fidl::encoding::Context) -> usize {
11505            24
11506        }
11507    }
11508
11509    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SbcEncoderSettings, D>
11510        for &SbcEncoderSettings
11511    {
11512        #[inline]
11513        unsafe fn encode(
11514            self,
11515            encoder: &mut fidl::encoding::Encoder<'_, D>,
11516            offset: usize,
11517            _depth: fidl::encoding::Depth,
11518        ) -> fidl::Result<()> {
11519            encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11520            // Delegate to tuple encoding.
11521            fidl::encoding::Encode::<SbcEncoderSettings, D>::encode(
11522                (
11523                    <SbcSubBands as fidl::encoding::ValueTypeMarker>::borrow(&self.sub_bands),
11524                    <SbcAllocation as fidl::encoding::ValueTypeMarker>::borrow(&self.allocation),
11525                    <SbcBlockCount as fidl::encoding::ValueTypeMarker>::borrow(&self.block_count),
11526                    <SbcChannelMode as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_mode),
11527                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.bit_pool),
11528                ),
11529                encoder,
11530                offset,
11531                _depth,
11532            )
11533        }
11534    }
11535    unsafe impl<
11536            D: fidl::encoding::ResourceDialect,
11537            T0: fidl::encoding::Encode<SbcSubBands, D>,
11538            T1: fidl::encoding::Encode<SbcAllocation, D>,
11539            T2: fidl::encoding::Encode<SbcBlockCount, D>,
11540            T3: fidl::encoding::Encode<SbcChannelMode, D>,
11541            T4: fidl::encoding::Encode<u64, D>,
11542        > fidl::encoding::Encode<SbcEncoderSettings, D> for (T0, T1, T2, T3, T4)
11543    {
11544        #[inline]
11545        unsafe fn encode(
11546            self,
11547            encoder: &mut fidl::encoding::Encoder<'_, D>,
11548            offset: usize,
11549            depth: fidl::encoding::Depth,
11550        ) -> fidl::Result<()> {
11551            encoder.debug_check_bounds::<SbcEncoderSettings>(offset);
11552            // Zero out padding regions. There's no need to apply masks
11553            // because the unmasked parts will be overwritten by fields.
11554            // Write the fields.
11555            self.0.encode(encoder, offset + 0, depth)?;
11556            self.1.encode(encoder, offset + 4, depth)?;
11557            self.2.encode(encoder, offset + 8, depth)?;
11558            self.3.encode(encoder, offset + 12, depth)?;
11559            self.4.encode(encoder, offset + 16, depth)?;
11560            Ok(())
11561        }
11562    }
11563
11564    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SbcEncoderSettings {
11565        #[inline(always)]
11566        fn new_empty() -> Self {
11567            Self {
11568                sub_bands: fidl::new_empty!(SbcSubBands, D),
11569                allocation: fidl::new_empty!(SbcAllocation, D),
11570                block_count: fidl::new_empty!(SbcBlockCount, D),
11571                channel_mode: fidl::new_empty!(SbcChannelMode, D),
11572                bit_pool: fidl::new_empty!(u64, D),
11573            }
11574        }
11575
11576        #[inline]
11577        unsafe fn decode(
11578            &mut self,
11579            decoder: &mut fidl::encoding::Decoder<'_, D>,
11580            offset: usize,
11581            _depth: fidl::encoding::Depth,
11582        ) -> fidl::Result<()> {
11583            decoder.debug_check_bounds::<Self>(offset);
11584            // Verify that padding bytes are zero.
11585            fidl::decode!(SbcSubBands, D, &mut self.sub_bands, decoder, offset + 0, _depth)?;
11586            fidl::decode!(SbcAllocation, D, &mut self.allocation, decoder, offset + 4, _depth)?;
11587            fidl::decode!(SbcBlockCount, D, &mut self.block_count, decoder, offset + 8, _depth)?;
11588            fidl::decode!(SbcChannelMode, D, &mut self.channel_mode, decoder, offset + 12, _depth)?;
11589            fidl::decode!(u64, D, &mut self.bit_pool, decoder, offset + 16, _depth)?;
11590            Ok(())
11591        }
11592    }
11593
11594    impl fidl::encoding::ValueTypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11595        type Borrowed<'a> = &'a Self;
11596        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11597            value
11598        }
11599    }
11600
11601    unsafe impl fidl::encoding::TypeMarker for StreamBufferSetRemovePayloadBufferRequest {
11602        type Owned = Self;
11603
11604        #[inline(always)]
11605        fn inline_align(_context: fidl::encoding::Context) -> usize {
11606            4
11607        }
11608
11609        #[inline(always)]
11610        fn inline_size(_context: fidl::encoding::Context) -> usize {
11611            4
11612        }
11613        #[inline(always)]
11614        fn encode_is_copy() -> bool {
11615            true
11616        }
11617
11618        #[inline(always)]
11619        fn decode_is_copy() -> bool {
11620            true
11621        }
11622    }
11623
11624    unsafe impl<D: fidl::encoding::ResourceDialect>
11625        fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D>
11626        for &StreamBufferSetRemovePayloadBufferRequest
11627    {
11628        #[inline]
11629        unsafe fn encode(
11630            self,
11631            encoder: &mut fidl::encoding::Encoder<'_, D>,
11632            offset: usize,
11633            _depth: fidl::encoding::Depth,
11634        ) -> fidl::Result<()> {
11635            encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11636            unsafe {
11637                // Copy the object into the buffer.
11638                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11639                (buf_ptr as *mut StreamBufferSetRemovePayloadBufferRequest).write_unaligned(
11640                    (self as *const StreamBufferSetRemovePayloadBufferRequest).read(),
11641                );
11642                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11643                // done second because the memcpy will write garbage to these bytes.
11644            }
11645            Ok(())
11646        }
11647    }
11648    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
11649        fidl::encoding::Encode<StreamBufferSetRemovePayloadBufferRequest, D> for (T0,)
11650    {
11651        #[inline]
11652        unsafe fn encode(
11653            self,
11654            encoder: &mut fidl::encoding::Encoder<'_, D>,
11655            offset: usize,
11656            depth: fidl::encoding::Depth,
11657        ) -> fidl::Result<()> {
11658            encoder.debug_check_bounds::<StreamBufferSetRemovePayloadBufferRequest>(offset);
11659            // Zero out padding regions. There's no need to apply masks
11660            // because the unmasked parts will be overwritten by fields.
11661            // Write the fields.
11662            self.0.encode(encoder, offset + 0, depth)?;
11663            Ok(())
11664        }
11665    }
11666
11667    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11668        for StreamBufferSetRemovePayloadBufferRequest
11669    {
11670        #[inline(always)]
11671        fn new_empty() -> Self {
11672            Self { id: fidl::new_empty!(u32, D) }
11673        }
11674
11675        #[inline]
11676        unsafe fn decode(
11677            &mut self,
11678            decoder: &mut fidl::encoding::Decoder<'_, D>,
11679            offset: usize,
11680            _depth: fidl::encoding::Depth,
11681        ) -> fidl::Result<()> {
11682            decoder.debug_check_bounds::<Self>(offset);
11683            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11684            // Verify that padding bytes are zero.
11685            // Copy from the buffer into the object.
11686            unsafe {
11687                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
11688            }
11689            Ok(())
11690        }
11691    }
11692
11693    impl fidl::encoding::ValueTypeMarker for StreamPacket {
11694        type Borrowed<'a> = &'a Self;
11695        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11696            value
11697        }
11698    }
11699
11700    unsafe impl fidl::encoding::TypeMarker for StreamPacket {
11701        type Owned = Self;
11702
11703        #[inline(always)]
11704        fn inline_align(_context: fidl::encoding::Context) -> usize {
11705            8
11706        }
11707
11708        #[inline(always)]
11709        fn inline_size(_context: fidl::encoding::Context) -> usize {
11710            56
11711        }
11712    }
11713
11714    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamPacket, D>
11715        for &StreamPacket
11716    {
11717        #[inline]
11718        unsafe fn encode(
11719            self,
11720            encoder: &mut fidl::encoding::Encoder<'_, D>,
11721            offset: usize,
11722            _depth: fidl::encoding::Depth,
11723        ) -> fidl::Result<()> {
11724            encoder.debug_check_bounds::<StreamPacket>(offset);
11725            unsafe {
11726                // Copy the object into the buffer.
11727                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11728                (buf_ptr as *mut StreamPacket)
11729                    .write_unaligned((self as *const StreamPacket).read());
11730                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11731                // done second because the memcpy will write garbage to these bytes.
11732                let padding_ptr = buf_ptr.offset(8) as *mut u64;
11733                let padding_mask = 0xffffffff00000000u64;
11734                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11735                let padding_ptr = buf_ptr.offset(32) as *mut u64;
11736                let padding_mask = 0xffffffff00000000u64;
11737                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
11738            }
11739            Ok(())
11740        }
11741    }
11742    unsafe impl<
11743            D: fidl::encoding::ResourceDialect,
11744            T0: fidl::encoding::Encode<i64, D>,
11745            T1: fidl::encoding::Encode<u32, D>,
11746            T2: fidl::encoding::Encode<u64, D>,
11747            T3: fidl::encoding::Encode<u64, D>,
11748            T4: fidl::encoding::Encode<u32, D>,
11749            T5: fidl::encoding::Encode<u64, D>,
11750            T6: fidl::encoding::Encode<u64, D>,
11751        > fidl::encoding::Encode<StreamPacket, D> for (T0, T1, T2, T3, T4, T5, T6)
11752    {
11753        #[inline]
11754        unsafe fn encode(
11755            self,
11756            encoder: &mut fidl::encoding::Encoder<'_, D>,
11757            offset: usize,
11758            depth: fidl::encoding::Depth,
11759        ) -> fidl::Result<()> {
11760            encoder.debug_check_bounds::<StreamPacket>(offset);
11761            // Zero out padding regions. There's no need to apply masks
11762            // because the unmasked parts will be overwritten by fields.
11763            unsafe {
11764                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11765                (ptr as *mut u64).write_unaligned(0);
11766            }
11767            unsafe {
11768                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
11769                (ptr as *mut u64).write_unaligned(0);
11770            }
11771            // Write the fields.
11772            self.0.encode(encoder, offset + 0, depth)?;
11773            self.1.encode(encoder, offset + 8, depth)?;
11774            self.2.encode(encoder, offset + 16, depth)?;
11775            self.3.encode(encoder, offset + 24, depth)?;
11776            self.4.encode(encoder, offset + 32, depth)?;
11777            self.5.encode(encoder, offset + 40, depth)?;
11778            self.6.encode(encoder, offset + 48, depth)?;
11779            Ok(())
11780        }
11781    }
11782
11783    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamPacket {
11784        #[inline(always)]
11785        fn new_empty() -> Self {
11786            Self {
11787                pts: fidl::new_empty!(i64, D),
11788                payload_buffer_id: fidl::new_empty!(u32, D),
11789                payload_offset: fidl::new_empty!(u64, D),
11790                payload_size: fidl::new_empty!(u64, D),
11791                flags: fidl::new_empty!(u32, D),
11792                buffer_config: fidl::new_empty!(u64, D),
11793                stream_segment_id: fidl::new_empty!(u64, D),
11794            }
11795        }
11796
11797        #[inline]
11798        unsafe fn decode(
11799            &mut self,
11800            decoder: &mut fidl::encoding::Decoder<'_, D>,
11801            offset: usize,
11802            _depth: fidl::encoding::Depth,
11803        ) -> fidl::Result<()> {
11804            decoder.debug_check_bounds::<Self>(offset);
11805            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11806            // Verify that padding bytes are zero.
11807            let ptr = unsafe { buf_ptr.offset(8) };
11808            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11809            let mask = 0xffffffff00000000u64;
11810            let maskedval = padval & mask;
11811            if maskedval != 0 {
11812                return Err(fidl::Error::NonZeroPadding {
11813                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11814                });
11815            }
11816            let ptr = unsafe { buf_ptr.offset(32) };
11817            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11818            let mask = 0xffffffff00000000u64;
11819            let maskedval = padval & mask;
11820            if maskedval != 0 {
11821                return Err(fidl::Error::NonZeroPadding {
11822                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
11823                });
11824            }
11825            // Copy from the buffer into the object.
11826            unsafe {
11827                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
11828            }
11829            Ok(())
11830        }
11831    }
11832
11833    impl fidl::encoding::ValueTypeMarker for StreamProcessorCloseCurrentStreamRequest {
11834        type Borrowed<'a> = &'a Self;
11835        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11836            value
11837        }
11838    }
11839
11840    unsafe impl fidl::encoding::TypeMarker for StreamProcessorCloseCurrentStreamRequest {
11841        type Owned = Self;
11842
11843        #[inline(always)]
11844        fn inline_align(_context: fidl::encoding::Context) -> usize {
11845            8
11846        }
11847
11848        #[inline(always)]
11849        fn inline_size(_context: fidl::encoding::Context) -> usize {
11850            16
11851        }
11852    }
11853
11854    unsafe impl<D: fidl::encoding::ResourceDialect>
11855        fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D>
11856        for &StreamProcessorCloseCurrentStreamRequest
11857    {
11858        #[inline]
11859        unsafe fn encode(
11860            self,
11861            encoder: &mut fidl::encoding::Encoder<'_, D>,
11862            offset: usize,
11863            _depth: fidl::encoding::Depth,
11864        ) -> fidl::Result<()> {
11865            encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11866            // Delegate to tuple encoding.
11867            fidl::encoding::Encode::<StreamProcessorCloseCurrentStreamRequest, D>::encode(
11868                (
11869                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
11870                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_input_buffers),
11871                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.release_output_buffers),
11872                ),
11873                encoder,
11874                offset,
11875                _depth,
11876            )
11877        }
11878    }
11879    unsafe impl<
11880            D: fidl::encoding::ResourceDialect,
11881            T0: fidl::encoding::Encode<u64, D>,
11882            T1: fidl::encoding::Encode<bool, D>,
11883            T2: fidl::encoding::Encode<bool, D>,
11884        > fidl::encoding::Encode<StreamProcessorCloseCurrentStreamRequest, D> for (T0, T1, T2)
11885    {
11886        #[inline]
11887        unsafe fn encode(
11888            self,
11889            encoder: &mut fidl::encoding::Encoder<'_, D>,
11890            offset: usize,
11891            depth: fidl::encoding::Depth,
11892        ) -> fidl::Result<()> {
11893            encoder.debug_check_bounds::<StreamProcessorCloseCurrentStreamRequest>(offset);
11894            // Zero out padding regions. There's no need to apply masks
11895            // because the unmasked parts will be overwritten by fields.
11896            unsafe {
11897                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11898                (ptr as *mut u64).write_unaligned(0);
11899            }
11900            // Write the fields.
11901            self.0.encode(encoder, offset + 0, depth)?;
11902            self.1.encode(encoder, offset + 8, depth)?;
11903            self.2.encode(encoder, offset + 9, depth)?;
11904            Ok(())
11905        }
11906    }
11907
11908    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11909        for StreamProcessorCloseCurrentStreamRequest
11910    {
11911        #[inline(always)]
11912        fn new_empty() -> Self {
11913            Self {
11914                stream_lifetime_ordinal: fidl::new_empty!(u64, D),
11915                release_input_buffers: fidl::new_empty!(bool, D),
11916                release_output_buffers: fidl::new_empty!(bool, D),
11917            }
11918        }
11919
11920        #[inline]
11921        unsafe fn decode(
11922            &mut self,
11923            decoder: &mut fidl::encoding::Decoder<'_, D>,
11924            offset: usize,
11925            _depth: fidl::encoding::Depth,
11926        ) -> fidl::Result<()> {
11927            decoder.debug_check_bounds::<Self>(offset);
11928            // Verify that padding bytes are zero.
11929            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11930            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11931            let mask = 0xffffffffffff0000u64;
11932            let maskedval = padval & mask;
11933            if maskedval != 0 {
11934                return Err(fidl::Error::NonZeroPadding {
11935                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11936                });
11937            }
11938            fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
11939            fidl::decode!(bool, D, &mut self.release_input_buffers, decoder, offset + 8, _depth)?;
11940            fidl::decode!(bool, D, &mut self.release_output_buffers, decoder, offset + 9, _depth)?;
11941            Ok(())
11942        }
11943    }
11944
11945    impl fidl::encoding::ValueTypeMarker for StreamProcessorCompleteOutputBufferPartialSettingsRequest {
11946        type Borrowed<'a> = &'a Self;
11947        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11948            value
11949        }
11950    }
11951
11952    unsafe impl fidl::encoding::TypeMarker
11953        for StreamProcessorCompleteOutputBufferPartialSettingsRequest
11954    {
11955        type Owned = Self;
11956
11957        #[inline(always)]
11958        fn inline_align(_context: fidl::encoding::Context) -> usize {
11959            8
11960        }
11961
11962        #[inline(always)]
11963        fn inline_size(_context: fidl::encoding::Context) -> usize {
11964            8
11965        }
11966        #[inline(always)]
11967        fn encode_is_copy() -> bool {
11968            true
11969        }
11970
11971        #[inline(always)]
11972        fn decode_is_copy() -> bool {
11973            true
11974        }
11975    }
11976
11977    unsafe impl<D: fidl::encoding::ResourceDialect>
11978        fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
11979        for &StreamProcessorCompleteOutputBufferPartialSettingsRequest
11980    {
11981        #[inline]
11982        unsafe fn encode(
11983            self,
11984            encoder: &mut fidl::encoding::Encoder<'_, D>,
11985            offset: usize,
11986            _depth: fidl::encoding::Depth,
11987        ) -> fidl::Result<()> {
11988            encoder
11989                .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
11990                    offset,
11991                );
11992            unsafe {
11993                // Copy the object into the buffer.
11994                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11995                (buf_ptr as *mut StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11996                    .write_unaligned(
11997                        (self as *const StreamProcessorCompleteOutputBufferPartialSettingsRequest)
11998                            .read(),
11999                    );
12000                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
12001                // done second because the memcpy will write garbage to these bytes.
12002            }
12003            Ok(())
12004        }
12005    }
12006    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12007        fidl::encoding::Encode<StreamProcessorCompleteOutputBufferPartialSettingsRequest, D>
12008        for (T0,)
12009    {
12010        #[inline]
12011        unsafe fn encode(
12012            self,
12013            encoder: &mut fidl::encoding::Encoder<'_, D>,
12014            offset: usize,
12015            depth: fidl::encoding::Depth,
12016        ) -> fidl::Result<()> {
12017            encoder
12018                .debug_check_bounds::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
12019                    offset,
12020                );
12021            // Zero out padding regions. There's no need to apply masks
12022            // because the unmasked parts will be overwritten by fields.
12023            // Write the fields.
12024            self.0.encode(encoder, offset + 0, depth)?;
12025            Ok(())
12026        }
12027    }
12028
12029    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12030        for StreamProcessorCompleteOutputBufferPartialSettingsRequest
12031    {
12032        #[inline(always)]
12033        fn new_empty() -> Self {
12034            Self { buffer_lifetime_ordinal: fidl::new_empty!(u64, D) }
12035        }
12036
12037        #[inline]
12038        unsafe fn decode(
12039            &mut self,
12040            decoder: &mut fidl::encoding::Decoder<'_, D>,
12041            offset: usize,
12042            _depth: fidl::encoding::Depth,
12043        ) -> fidl::Result<()> {
12044            decoder.debug_check_bounds::<Self>(offset);
12045            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12046            // Verify that padding bytes are zero.
12047            // Copy from the buffer into the object.
12048            unsafe {
12049                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12050            }
12051            Ok(())
12052        }
12053    }
12054
12055    impl fidl::encoding::ValueTypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
12056        type Borrowed<'a> = &'a Self;
12057        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12058            value
12059        }
12060    }
12061
12062    unsafe impl fidl::encoding::TypeMarker for StreamProcessorFlushEndOfStreamAndCloseStreamRequest {
12063        type Owned = Self;
12064
12065        #[inline(always)]
12066        fn inline_align(_context: fidl::encoding::Context) -> usize {
12067            8
12068        }
12069
12070        #[inline(always)]
12071        fn inline_size(_context: fidl::encoding::Context) -> usize {
12072            8
12073        }
12074        #[inline(always)]
12075        fn encode_is_copy() -> bool {
12076            true
12077        }
12078
12079        #[inline(always)]
12080        fn decode_is_copy() -> bool {
12081            true
12082        }
12083    }
12084
12085    unsafe impl<D: fidl::encoding::ResourceDialect>
12086        fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D>
12087        for &StreamProcessorFlushEndOfStreamAndCloseStreamRequest
12088    {
12089        #[inline]
12090        unsafe fn encode(
12091            self,
12092            encoder: &mut fidl::encoding::Encoder<'_, D>,
12093            offset: usize,
12094            _depth: fidl::encoding::Depth,
12095        ) -> fidl::Result<()> {
12096            encoder
12097                .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
12098            unsafe {
12099                // Copy the object into the buffer.
12100                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12101                (buf_ptr as *mut StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
12102                    .write_unaligned(
12103                        (self as *const StreamProcessorFlushEndOfStreamAndCloseStreamRequest)
12104                            .read(),
12105                    );
12106                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
12107                // done second because the memcpy will write garbage to these bytes.
12108            }
12109            Ok(())
12110        }
12111    }
12112    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12113        fidl::encoding::Encode<StreamProcessorFlushEndOfStreamAndCloseStreamRequest, D> for (T0,)
12114    {
12115        #[inline]
12116        unsafe fn encode(
12117            self,
12118            encoder: &mut fidl::encoding::Encoder<'_, D>,
12119            offset: usize,
12120            depth: fidl::encoding::Depth,
12121        ) -> fidl::Result<()> {
12122            encoder
12123                .debug_check_bounds::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(offset);
12124            // Zero out padding regions. There's no need to apply masks
12125            // because the unmasked parts will be overwritten by fields.
12126            // Write the fields.
12127            self.0.encode(encoder, offset + 0, depth)?;
12128            Ok(())
12129        }
12130    }
12131
12132    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12133        for StreamProcessorFlushEndOfStreamAndCloseStreamRequest
12134    {
12135        #[inline(always)]
12136        fn new_empty() -> Self {
12137            Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
12138        }
12139
12140        #[inline]
12141        unsafe fn decode(
12142            &mut self,
12143            decoder: &mut fidl::encoding::Decoder<'_, D>,
12144            offset: usize,
12145            _depth: fidl::encoding::Depth,
12146        ) -> fidl::Result<()> {
12147            decoder.debug_check_bounds::<Self>(offset);
12148            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12149            // Verify that padding bytes are zero.
12150            // Copy from the buffer into the object.
12151            unsafe {
12152                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12153            }
12154            Ok(())
12155        }
12156    }
12157
12158    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnFreeInputPacketRequest {
12159        type Borrowed<'a> = &'a Self;
12160        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12161            value
12162        }
12163    }
12164
12165    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnFreeInputPacketRequest {
12166        type Owned = Self;
12167
12168        #[inline(always)]
12169        fn inline_align(_context: fidl::encoding::Context) -> usize {
12170            8
12171        }
12172
12173        #[inline(always)]
12174        fn inline_size(_context: fidl::encoding::Context) -> usize {
12175            16
12176        }
12177    }
12178
12179    unsafe impl<D: fidl::encoding::ResourceDialect>
12180        fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D>
12181        for &StreamProcessorOnFreeInputPacketRequest
12182    {
12183        #[inline]
12184        unsafe fn encode(
12185            self,
12186            encoder: &mut fidl::encoding::Encoder<'_, D>,
12187            offset: usize,
12188            _depth: fidl::encoding::Depth,
12189        ) -> fidl::Result<()> {
12190            encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
12191            // Delegate to tuple encoding.
12192            fidl::encoding::Encode::<StreamProcessorOnFreeInputPacketRequest, D>::encode(
12193                (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
12194                    &self.free_input_packet,
12195                ),),
12196                encoder,
12197                offset,
12198                _depth,
12199            )
12200        }
12201    }
12202    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
12203        fidl::encoding::Encode<StreamProcessorOnFreeInputPacketRequest, D> for (T0,)
12204    {
12205        #[inline]
12206        unsafe fn encode(
12207            self,
12208            encoder: &mut fidl::encoding::Encoder<'_, D>,
12209            offset: usize,
12210            depth: fidl::encoding::Depth,
12211        ) -> fidl::Result<()> {
12212            encoder.debug_check_bounds::<StreamProcessorOnFreeInputPacketRequest>(offset);
12213            // Zero out padding regions. There's no need to apply masks
12214            // because the unmasked parts will be overwritten by fields.
12215            // Write the fields.
12216            self.0.encode(encoder, offset + 0, depth)?;
12217            Ok(())
12218        }
12219    }
12220
12221    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12222        for StreamProcessorOnFreeInputPacketRequest
12223    {
12224        #[inline(always)]
12225        fn new_empty() -> Self {
12226            Self { free_input_packet: fidl::new_empty!(PacketHeader, D) }
12227        }
12228
12229        #[inline]
12230        unsafe fn decode(
12231            &mut self,
12232            decoder: &mut fidl::encoding::Decoder<'_, D>,
12233            offset: usize,
12234            _depth: fidl::encoding::Depth,
12235        ) -> fidl::Result<()> {
12236            decoder.debug_check_bounds::<Self>(offset);
12237            // Verify that padding bytes are zero.
12238            fidl::decode!(
12239                PacketHeader,
12240                D,
12241                &mut self.free_input_packet,
12242                decoder,
12243                offset + 0,
12244                _depth
12245            )?;
12246            Ok(())
12247        }
12248    }
12249
12250    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnInputConstraintsRequest {
12251        type Borrowed<'a> = &'a Self;
12252        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12253            value
12254        }
12255    }
12256
12257    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnInputConstraintsRequest {
12258        type Owned = Self;
12259
12260        #[inline(always)]
12261        fn inline_align(_context: fidl::encoding::Context) -> usize {
12262            8
12263        }
12264
12265        #[inline(always)]
12266        fn inline_size(_context: fidl::encoding::Context) -> usize {
12267            16
12268        }
12269    }
12270
12271    unsafe impl<D: fidl::encoding::ResourceDialect>
12272        fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D>
12273        for &StreamProcessorOnInputConstraintsRequest
12274    {
12275        #[inline]
12276        unsafe fn encode(
12277            self,
12278            encoder: &mut fidl::encoding::Encoder<'_, D>,
12279            offset: usize,
12280            _depth: fidl::encoding::Depth,
12281        ) -> fidl::Result<()> {
12282            encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12283            // Delegate to tuple encoding.
12284            fidl::encoding::Encode::<StreamProcessorOnInputConstraintsRequest, D>::encode(
12285                (<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12286                    &self.input_constraints,
12287                ),),
12288                encoder,
12289                offset,
12290                _depth,
12291            )
12292        }
12293    }
12294    unsafe impl<
12295            D: fidl::encoding::ResourceDialect,
12296            T0: fidl::encoding::Encode<StreamBufferConstraints, D>,
12297        > fidl::encoding::Encode<StreamProcessorOnInputConstraintsRequest, D> for (T0,)
12298    {
12299        #[inline]
12300        unsafe fn encode(
12301            self,
12302            encoder: &mut fidl::encoding::Encoder<'_, D>,
12303            offset: usize,
12304            depth: fidl::encoding::Depth,
12305        ) -> fidl::Result<()> {
12306            encoder.debug_check_bounds::<StreamProcessorOnInputConstraintsRequest>(offset);
12307            // Zero out padding regions. There's no need to apply masks
12308            // because the unmasked parts will be overwritten by fields.
12309            // Write the fields.
12310            self.0.encode(encoder, offset + 0, depth)?;
12311            Ok(())
12312        }
12313    }
12314
12315    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12316        for StreamProcessorOnInputConstraintsRequest
12317    {
12318        #[inline(always)]
12319        fn new_empty() -> Self {
12320            Self { input_constraints: fidl::new_empty!(StreamBufferConstraints, D) }
12321        }
12322
12323        #[inline]
12324        unsafe fn decode(
12325            &mut self,
12326            decoder: &mut fidl::encoding::Decoder<'_, D>,
12327            offset: usize,
12328            _depth: fidl::encoding::Depth,
12329        ) -> fidl::Result<()> {
12330            decoder.debug_check_bounds::<Self>(offset);
12331            // Verify that padding bytes are zero.
12332            fidl::decode!(
12333                StreamBufferConstraints,
12334                D,
12335                &mut self.input_constraints,
12336                decoder,
12337                offset + 0,
12338                _depth
12339            )?;
12340            Ok(())
12341        }
12342    }
12343
12344    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputConstraintsRequest {
12345        type Borrowed<'a> = &'a Self;
12346        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12347            value
12348        }
12349    }
12350
12351    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputConstraintsRequest {
12352        type Owned = Self;
12353
12354        #[inline(always)]
12355        fn inline_align(_context: fidl::encoding::Context) -> usize {
12356            8
12357        }
12358
12359        #[inline(always)]
12360        fn inline_size(_context: fidl::encoding::Context) -> usize {
12361            16
12362        }
12363    }
12364
12365    unsafe impl<D: fidl::encoding::ResourceDialect>
12366        fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D>
12367        for &StreamProcessorOnOutputConstraintsRequest
12368    {
12369        #[inline]
12370        unsafe fn encode(
12371            self,
12372            encoder: &mut fidl::encoding::Encoder<'_, D>,
12373            offset: usize,
12374            _depth: fidl::encoding::Depth,
12375        ) -> fidl::Result<()> {
12376            encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12377            // Delegate to tuple encoding.
12378            fidl::encoding::Encode::<StreamProcessorOnOutputConstraintsRequest, D>::encode(
12379                (<StreamOutputConstraints as fidl::encoding::ValueTypeMarker>::borrow(
12380                    &self.output_config,
12381                ),),
12382                encoder,
12383                offset,
12384                _depth,
12385            )
12386        }
12387    }
12388    unsafe impl<
12389            D: fidl::encoding::ResourceDialect,
12390            T0: fidl::encoding::Encode<StreamOutputConstraints, D>,
12391        > fidl::encoding::Encode<StreamProcessorOnOutputConstraintsRequest, D> for (T0,)
12392    {
12393        #[inline]
12394        unsafe fn encode(
12395            self,
12396            encoder: &mut fidl::encoding::Encoder<'_, D>,
12397            offset: usize,
12398            depth: fidl::encoding::Depth,
12399        ) -> fidl::Result<()> {
12400            encoder.debug_check_bounds::<StreamProcessorOnOutputConstraintsRequest>(offset);
12401            // Zero out padding regions. There's no need to apply masks
12402            // because the unmasked parts will be overwritten by fields.
12403            // Write the fields.
12404            self.0.encode(encoder, offset + 0, depth)?;
12405            Ok(())
12406        }
12407    }
12408
12409    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12410        for StreamProcessorOnOutputConstraintsRequest
12411    {
12412        #[inline(always)]
12413        fn new_empty() -> Self {
12414            Self { output_config: fidl::new_empty!(StreamOutputConstraints, D) }
12415        }
12416
12417        #[inline]
12418        unsafe fn decode(
12419            &mut self,
12420            decoder: &mut fidl::encoding::Decoder<'_, D>,
12421            offset: usize,
12422            _depth: fidl::encoding::Depth,
12423        ) -> fidl::Result<()> {
12424            decoder.debug_check_bounds::<Self>(offset);
12425            // Verify that padding bytes are zero.
12426            fidl::decode!(
12427                StreamOutputConstraints,
12428                D,
12429                &mut self.output_config,
12430                decoder,
12431                offset + 0,
12432                _depth
12433            )?;
12434            Ok(())
12435        }
12436    }
12437
12438    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12439        type Borrowed<'a> = &'a Self;
12440        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12441            value
12442        }
12443    }
12444
12445    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputEndOfStreamRequest {
12446        type Owned = Self;
12447
12448        #[inline(always)]
12449        fn inline_align(_context: fidl::encoding::Context) -> usize {
12450            8
12451        }
12452
12453        #[inline(always)]
12454        fn inline_size(_context: fidl::encoding::Context) -> usize {
12455            16
12456        }
12457    }
12458
12459    unsafe impl<D: fidl::encoding::ResourceDialect>
12460        fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D>
12461        for &StreamProcessorOnOutputEndOfStreamRequest
12462    {
12463        #[inline]
12464        unsafe fn encode(
12465            self,
12466            encoder: &mut fidl::encoding::Encoder<'_, D>,
12467            offset: usize,
12468            _depth: fidl::encoding::Depth,
12469        ) -> fidl::Result<()> {
12470            encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12471            // Delegate to tuple encoding.
12472            fidl::encoding::Encode::<StreamProcessorOnOutputEndOfStreamRequest, D>::encode(
12473                (
12474                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12475                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12476                ),
12477                encoder,
12478                offset,
12479                _depth,
12480            )
12481        }
12482    }
12483    unsafe impl<
12484            D: fidl::encoding::ResourceDialect,
12485            T0: fidl::encoding::Encode<u64, D>,
12486            T1: fidl::encoding::Encode<bool, D>,
12487        > fidl::encoding::Encode<StreamProcessorOnOutputEndOfStreamRequest, D> for (T0, T1)
12488    {
12489        #[inline]
12490        unsafe fn encode(
12491            self,
12492            encoder: &mut fidl::encoding::Encoder<'_, D>,
12493            offset: usize,
12494            depth: fidl::encoding::Depth,
12495        ) -> fidl::Result<()> {
12496            encoder.debug_check_bounds::<StreamProcessorOnOutputEndOfStreamRequest>(offset);
12497            // Zero out padding regions. There's no need to apply masks
12498            // because the unmasked parts will be overwritten by fields.
12499            unsafe {
12500                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12501                (ptr as *mut u64).write_unaligned(0);
12502            }
12503            // Write the fields.
12504            self.0.encode(encoder, offset + 0, depth)?;
12505            self.1.encode(encoder, offset + 8, depth)?;
12506            Ok(())
12507        }
12508    }
12509
12510    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12511        for StreamProcessorOnOutputEndOfStreamRequest
12512    {
12513        #[inline(always)]
12514        fn new_empty() -> Self {
12515            Self {
12516                stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12517                error_detected_before: fidl::new_empty!(bool, D),
12518            }
12519        }
12520
12521        #[inline]
12522        unsafe fn decode(
12523            &mut self,
12524            decoder: &mut fidl::encoding::Decoder<'_, D>,
12525            offset: usize,
12526            _depth: fidl::encoding::Depth,
12527        ) -> fidl::Result<()> {
12528            decoder.debug_check_bounds::<Self>(offset);
12529            // Verify that padding bytes are zero.
12530            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12531            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12532            let mask = 0xffffffffffffff00u64;
12533            let maskedval = padval & mask;
12534            if maskedval != 0 {
12535                return Err(fidl::Error::NonZeroPadding {
12536                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12537                });
12538            }
12539            fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12540            fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 8, _depth)?;
12541            Ok(())
12542        }
12543    }
12544
12545    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputFormatRequest {
12546        type Borrowed<'a> = &'a Self;
12547        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12548            value
12549        }
12550    }
12551
12552    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputFormatRequest {
12553        type Owned = Self;
12554
12555        #[inline(always)]
12556        fn inline_align(_context: fidl::encoding::Context) -> usize {
12557            8
12558        }
12559
12560        #[inline(always)]
12561        fn inline_size(_context: fidl::encoding::Context) -> usize {
12562            16
12563        }
12564    }
12565
12566    unsafe impl<D: fidl::encoding::ResourceDialect>
12567        fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D>
12568        for &StreamProcessorOnOutputFormatRequest
12569    {
12570        #[inline]
12571        unsafe fn encode(
12572            self,
12573            encoder: &mut fidl::encoding::Encoder<'_, D>,
12574            offset: usize,
12575            _depth: fidl::encoding::Depth,
12576        ) -> fidl::Result<()> {
12577            encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12578            // Delegate to tuple encoding.
12579            fidl::encoding::Encode::<StreamProcessorOnOutputFormatRequest, D>::encode(
12580                (<StreamOutputFormat as fidl::encoding::ValueTypeMarker>::borrow(
12581                    &self.output_format,
12582                ),),
12583                encoder,
12584                offset,
12585                _depth,
12586            )
12587        }
12588    }
12589    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamOutputFormat, D>>
12590        fidl::encoding::Encode<StreamProcessorOnOutputFormatRequest, D> for (T0,)
12591    {
12592        #[inline]
12593        unsafe fn encode(
12594            self,
12595            encoder: &mut fidl::encoding::Encoder<'_, D>,
12596            offset: usize,
12597            depth: fidl::encoding::Depth,
12598        ) -> fidl::Result<()> {
12599            encoder.debug_check_bounds::<StreamProcessorOnOutputFormatRequest>(offset);
12600            // Zero out padding regions. There's no need to apply masks
12601            // because the unmasked parts will be overwritten by fields.
12602            // Write the fields.
12603            self.0.encode(encoder, offset + 0, depth)?;
12604            Ok(())
12605        }
12606    }
12607
12608    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12609        for StreamProcessorOnOutputFormatRequest
12610    {
12611        #[inline(always)]
12612        fn new_empty() -> Self {
12613            Self { output_format: fidl::new_empty!(StreamOutputFormat, D) }
12614        }
12615
12616        #[inline]
12617        unsafe fn decode(
12618            &mut self,
12619            decoder: &mut fidl::encoding::Decoder<'_, D>,
12620            offset: usize,
12621            _depth: fidl::encoding::Depth,
12622        ) -> fidl::Result<()> {
12623            decoder.debug_check_bounds::<Self>(offset);
12624            // Verify that padding bytes are zero.
12625            fidl::decode!(
12626                StreamOutputFormat,
12627                D,
12628                &mut self.output_format,
12629                decoder,
12630                offset + 0,
12631                _depth
12632            )?;
12633            Ok(())
12634        }
12635    }
12636
12637    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnOutputPacketRequest {
12638        type Borrowed<'a> = &'a Self;
12639        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12640            value
12641        }
12642    }
12643
12644    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnOutputPacketRequest {
12645        type Owned = Self;
12646
12647        #[inline(always)]
12648        fn inline_align(_context: fidl::encoding::Context) -> usize {
12649            8
12650        }
12651
12652        #[inline(always)]
12653        fn inline_size(_context: fidl::encoding::Context) -> usize {
12654            24
12655        }
12656    }
12657
12658    unsafe impl<D: fidl::encoding::ResourceDialect>
12659        fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D>
12660        for &StreamProcessorOnOutputPacketRequest
12661    {
12662        #[inline]
12663        unsafe fn encode(
12664            self,
12665            encoder: &mut fidl::encoding::Encoder<'_, D>,
12666            offset: usize,
12667            _depth: fidl::encoding::Depth,
12668        ) -> fidl::Result<()> {
12669            encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12670            // Delegate to tuple encoding.
12671            fidl::encoding::Encode::<StreamProcessorOnOutputPacketRequest, D>::encode(
12672                (
12673                    <Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.output_packet),
12674                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_before),
12675                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.error_detected_during),
12676                ),
12677                encoder,
12678                offset,
12679                _depth,
12680            )
12681        }
12682    }
12683    unsafe impl<
12684            D: fidl::encoding::ResourceDialect,
12685            T0: fidl::encoding::Encode<Packet, D>,
12686            T1: fidl::encoding::Encode<bool, D>,
12687            T2: fidl::encoding::Encode<bool, D>,
12688        > fidl::encoding::Encode<StreamProcessorOnOutputPacketRequest, D> for (T0, T1, T2)
12689    {
12690        #[inline]
12691        unsafe fn encode(
12692            self,
12693            encoder: &mut fidl::encoding::Encoder<'_, D>,
12694            offset: usize,
12695            depth: fidl::encoding::Depth,
12696        ) -> fidl::Result<()> {
12697            encoder.debug_check_bounds::<StreamProcessorOnOutputPacketRequest>(offset);
12698            // Zero out padding regions. There's no need to apply masks
12699            // because the unmasked parts will be overwritten by fields.
12700            unsafe {
12701                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
12702                (ptr as *mut u64).write_unaligned(0);
12703            }
12704            // Write the fields.
12705            self.0.encode(encoder, offset + 0, depth)?;
12706            self.1.encode(encoder, offset + 16, depth)?;
12707            self.2.encode(encoder, offset + 17, depth)?;
12708            Ok(())
12709        }
12710    }
12711
12712    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12713        for StreamProcessorOnOutputPacketRequest
12714    {
12715        #[inline(always)]
12716        fn new_empty() -> Self {
12717            Self {
12718                output_packet: fidl::new_empty!(Packet, D),
12719                error_detected_before: fidl::new_empty!(bool, D),
12720                error_detected_during: fidl::new_empty!(bool, D),
12721            }
12722        }
12723
12724        #[inline]
12725        unsafe fn decode(
12726            &mut self,
12727            decoder: &mut fidl::encoding::Decoder<'_, D>,
12728            offset: usize,
12729            _depth: fidl::encoding::Depth,
12730        ) -> fidl::Result<()> {
12731            decoder.debug_check_bounds::<Self>(offset);
12732            // Verify that padding bytes are zero.
12733            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
12734            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12735            let mask = 0xffffffffffff0000u64;
12736            let maskedval = padval & mask;
12737            if maskedval != 0 {
12738                return Err(fidl::Error::NonZeroPadding {
12739                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
12740                });
12741            }
12742            fidl::decode!(Packet, D, &mut self.output_packet, decoder, offset + 0, _depth)?;
12743            fidl::decode!(bool, D, &mut self.error_detected_before, decoder, offset + 16, _depth)?;
12744            fidl::decode!(bool, D, &mut self.error_detected_during, decoder, offset + 17, _depth)?;
12745            Ok(())
12746        }
12747    }
12748
12749    impl fidl::encoding::ValueTypeMarker for StreamProcessorOnStreamFailedRequest {
12750        type Borrowed<'a> = &'a Self;
12751        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12752            value
12753        }
12754    }
12755
12756    unsafe impl fidl::encoding::TypeMarker for StreamProcessorOnStreamFailedRequest {
12757        type Owned = Self;
12758
12759        #[inline(always)]
12760        fn inline_align(_context: fidl::encoding::Context) -> usize {
12761            8
12762        }
12763
12764        #[inline(always)]
12765        fn inline_size(_context: fidl::encoding::Context) -> usize {
12766            16
12767        }
12768    }
12769
12770    unsafe impl<D: fidl::encoding::ResourceDialect>
12771        fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D>
12772        for &StreamProcessorOnStreamFailedRequest
12773    {
12774        #[inline]
12775        unsafe fn encode(
12776            self,
12777            encoder: &mut fidl::encoding::Encoder<'_, D>,
12778            offset: usize,
12779            _depth: fidl::encoding::Depth,
12780        ) -> fidl::Result<()> {
12781            encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12782            // Delegate to tuple encoding.
12783            fidl::encoding::Encode::<StreamProcessorOnStreamFailedRequest, D>::encode(
12784                (
12785                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12786                    <StreamError as fidl::encoding::ValueTypeMarker>::borrow(&self.error),
12787                ),
12788                encoder,
12789                offset,
12790                _depth,
12791            )
12792        }
12793    }
12794    unsafe impl<
12795            D: fidl::encoding::ResourceDialect,
12796            T0: fidl::encoding::Encode<u64, D>,
12797            T1: fidl::encoding::Encode<StreamError, D>,
12798        > fidl::encoding::Encode<StreamProcessorOnStreamFailedRequest, D> for (T0, T1)
12799    {
12800        #[inline]
12801        unsafe fn encode(
12802            self,
12803            encoder: &mut fidl::encoding::Encoder<'_, D>,
12804            offset: usize,
12805            depth: fidl::encoding::Depth,
12806        ) -> fidl::Result<()> {
12807            encoder.debug_check_bounds::<StreamProcessorOnStreamFailedRequest>(offset);
12808            // Zero out padding regions. There's no need to apply masks
12809            // because the unmasked parts will be overwritten by fields.
12810            unsafe {
12811                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
12812                (ptr as *mut u64).write_unaligned(0);
12813            }
12814            // Write the fields.
12815            self.0.encode(encoder, offset + 0, depth)?;
12816            self.1.encode(encoder, offset + 8, depth)?;
12817            Ok(())
12818        }
12819    }
12820
12821    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12822        for StreamProcessorOnStreamFailedRequest
12823    {
12824        #[inline(always)]
12825        fn new_empty() -> Self {
12826            Self {
12827                stream_lifetime_ordinal: fidl::new_empty!(u64, D),
12828                error: fidl::new_empty!(StreamError, D),
12829            }
12830        }
12831
12832        #[inline]
12833        unsafe fn decode(
12834            &mut self,
12835            decoder: &mut fidl::encoding::Decoder<'_, D>,
12836            offset: usize,
12837            _depth: fidl::encoding::Depth,
12838        ) -> fidl::Result<()> {
12839            decoder.debug_check_bounds::<Self>(offset);
12840            // Verify that padding bytes are zero.
12841            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
12842            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12843            let mask = 0xffffffff00000000u64;
12844            let maskedval = padval & mask;
12845            if maskedval != 0 {
12846                return Err(fidl::Error::NonZeroPadding {
12847                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
12848                });
12849            }
12850            fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
12851            fidl::decode!(StreamError, D, &mut self.error, decoder, offset + 8, _depth)?;
12852            Ok(())
12853        }
12854    }
12855
12856    impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12857        type Borrowed<'a> = &'a Self;
12858        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12859            value
12860        }
12861    }
12862
12863    unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputEndOfStreamRequest {
12864        type Owned = Self;
12865
12866        #[inline(always)]
12867        fn inline_align(_context: fidl::encoding::Context) -> usize {
12868            8
12869        }
12870
12871        #[inline(always)]
12872        fn inline_size(_context: fidl::encoding::Context) -> usize {
12873            8
12874        }
12875        #[inline(always)]
12876        fn encode_is_copy() -> bool {
12877            true
12878        }
12879
12880        #[inline(always)]
12881        fn decode_is_copy() -> bool {
12882            true
12883        }
12884    }
12885
12886    unsafe impl<D: fidl::encoding::ResourceDialect>
12887        fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D>
12888        for &StreamProcessorQueueInputEndOfStreamRequest
12889    {
12890        #[inline]
12891        unsafe fn encode(
12892            self,
12893            encoder: &mut fidl::encoding::Encoder<'_, D>,
12894            offset: usize,
12895            _depth: fidl::encoding::Depth,
12896        ) -> fidl::Result<()> {
12897            encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12898            unsafe {
12899                // Copy the object into the buffer.
12900                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12901                (buf_ptr as *mut StreamProcessorQueueInputEndOfStreamRequest).write_unaligned(
12902                    (self as *const StreamProcessorQueueInputEndOfStreamRequest).read(),
12903                );
12904                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
12905                // done second because the memcpy will write garbage to these bytes.
12906            }
12907            Ok(())
12908        }
12909    }
12910    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
12911        fidl::encoding::Encode<StreamProcessorQueueInputEndOfStreamRequest, D> for (T0,)
12912    {
12913        #[inline]
12914        unsafe fn encode(
12915            self,
12916            encoder: &mut fidl::encoding::Encoder<'_, D>,
12917            offset: usize,
12918            depth: fidl::encoding::Depth,
12919        ) -> fidl::Result<()> {
12920            encoder.debug_check_bounds::<StreamProcessorQueueInputEndOfStreamRequest>(offset);
12921            // Zero out padding regions. There's no need to apply masks
12922            // because the unmasked parts will be overwritten by fields.
12923            // Write the fields.
12924            self.0.encode(encoder, offset + 0, depth)?;
12925            Ok(())
12926        }
12927    }
12928
12929    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12930        for StreamProcessorQueueInputEndOfStreamRequest
12931    {
12932        #[inline(always)]
12933        fn new_empty() -> Self {
12934            Self { stream_lifetime_ordinal: fidl::new_empty!(u64, D) }
12935        }
12936
12937        #[inline]
12938        unsafe fn decode(
12939            &mut self,
12940            decoder: &mut fidl::encoding::Decoder<'_, D>,
12941            offset: usize,
12942            _depth: fidl::encoding::Depth,
12943        ) -> fidl::Result<()> {
12944            decoder.debug_check_bounds::<Self>(offset);
12945            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12946            // Verify that padding bytes are zero.
12947            // Copy from the buffer into the object.
12948            unsafe {
12949                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12950            }
12951            Ok(())
12952        }
12953    }
12954
12955    impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12956        type Borrowed<'a> = &'a Self;
12957        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12958            value
12959        }
12960    }
12961
12962    unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputFormatDetailsRequest {
12963        type Owned = Self;
12964
12965        #[inline(always)]
12966        fn inline_align(_context: fidl::encoding::Context) -> usize {
12967            8
12968        }
12969
12970        #[inline(always)]
12971        fn inline_size(_context: fidl::encoding::Context) -> usize {
12972            24
12973        }
12974    }
12975
12976    unsafe impl<D: fidl::encoding::ResourceDialect>
12977        fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D>
12978        for &StreamProcessorQueueInputFormatDetailsRequest
12979    {
12980        #[inline]
12981        unsafe fn encode(
12982            self,
12983            encoder: &mut fidl::encoding::Encoder<'_, D>,
12984            offset: usize,
12985            _depth: fidl::encoding::Depth,
12986        ) -> fidl::Result<()> {
12987            encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
12988            // Delegate to tuple encoding.
12989            fidl::encoding::Encode::<StreamProcessorQueueInputFormatDetailsRequest, D>::encode(
12990                (
12991                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_lifetime_ordinal),
12992                    <FormatDetails as fidl::encoding::ValueTypeMarker>::borrow(
12993                        &self.format_details,
12994                    ),
12995                ),
12996                encoder,
12997                offset,
12998                _depth,
12999            )
13000        }
13001    }
13002    unsafe impl<
13003            D: fidl::encoding::ResourceDialect,
13004            T0: fidl::encoding::Encode<u64, D>,
13005            T1: fidl::encoding::Encode<FormatDetails, D>,
13006        > fidl::encoding::Encode<StreamProcessorQueueInputFormatDetailsRequest, D> for (T0, T1)
13007    {
13008        #[inline]
13009        unsafe fn encode(
13010            self,
13011            encoder: &mut fidl::encoding::Encoder<'_, D>,
13012            offset: usize,
13013            depth: fidl::encoding::Depth,
13014        ) -> fidl::Result<()> {
13015            encoder.debug_check_bounds::<StreamProcessorQueueInputFormatDetailsRequest>(offset);
13016            // Zero out padding regions. There's no need to apply masks
13017            // because the unmasked parts will be overwritten by fields.
13018            // Write the fields.
13019            self.0.encode(encoder, offset + 0, depth)?;
13020            self.1.encode(encoder, offset + 8, depth)?;
13021            Ok(())
13022        }
13023    }
13024
13025    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13026        for StreamProcessorQueueInputFormatDetailsRequest
13027    {
13028        #[inline(always)]
13029        fn new_empty() -> Self {
13030            Self {
13031                stream_lifetime_ordinal: fidl::new_empty!(u64, D),
13032                format_details: fidl::new_empty!(FormatDetails, D),
13033            }
13034        }
13035
13036        #[inline]
13037        unsafe fn decode(
13038            &mut self,
13039            decoder: &mut fidl::encoding::Decoder<'_, D>,
13040            offset: usize,
13041            _depth: fidl::encoding::Depth,
13042        ) -> fidl::Result<()> {
13043            decoder.debug_check_bounds::<Self>(offset);
13044            // Verify that padding bytes are zero.
13045            fidl::decode!(u64, D, &mut self.stream_lifetime_ordinal, decoder, offset + 0, _depth)?;
13046            fidl::decode!(FormatDetails, D, &mut self.format_details, decoder, offset + 8, _depth)?;
13047            Ok(())
13048        }
13049    }
13050
13051    impl fidl::encoding::ValueTypeMarker for StreamProcessorQueueInputPacketRequest {
13052        type Borrowed<'a> = &'a Self;
13053        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13054            value
13055        }
13056    }
13057
13058    unsafe impl fidl::encoding::TypeMarker for StreamProcessorQueueInputPacketRequest {
13059        type Owned = Self;
13060
13061        #[inline(always)]
13062        fn inline_align(_context: fidl::encoding::Context) -> usize {
13063            8
13064        }
13065
13066        #[inline(always)]
13067        fn inline_size(_context: fidl::encoding::Context) -> usize {
13068            16
13069        }
13070    }
13071
13072    unsafe impl<D: fidl::encoding::ResourceDialect>
13073        fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D>
13074        for &StreamProcessorQueueInputPacketRequest
13075    {
13076        #[inline]
13077        unsafe fn encode(
13078            self,
13079            encoder: &mut fidl::encoding::Encoder<'_, D>,
13080            offset: usize,
13081            _depth: fidl::encoding::Depth,
13082        ) -> fidl::Result<()> {
13083            encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
13084            // Delegate to tuple encoding.
13085            fidl::encoding::Encode::<StreamProcessorQueueInputPacketRequest, D>::encode(
13086                (<Packet as fidl::encoding::ValueTypeMarker>::borrow(&self.packet),),
13087                encoder,
13088                offset,
13089                _depth,
13090            )
13091        }
13092    }
13093    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Packet, D>>
13094        fidl::encoding::Encode<StreamProcessorQueueInputPacketRequest, D> for (T0,)
13095    {
13096        #[inline]
13097        unsafe fn encode(
13098            self,
13099            encoder: &mut fidl::encoding::Encoder<'_, D>,
13100            offset: usize,
13101            depth: fidl::encoding::Depth,
13102        ) -> fidl::Result<()> {
13103            encoder.debug_check_bounds::<StreamProcessorQueueInputPacketRequest>(offset);
13104            // Zero out padding regions. There's no need to apply masks
13105            // because the unmasked parts will be overwritten by fields.
13106            // Write the fields.
13107            self.0.encode(encoder, offset + 0, depth)?;
13108            Ok(())
13109        }
13110    }
13111
13112    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13113        for StreamProcessorQueueInputPacketRequest
13114    {
13115        #[inline(always)]
13116        fn new_empty() -> Self {
13117            Self { packet: fidl::new_empty!(Packet, D) }
13118        }
13119
13120        #[inline]
13121        unsafe fn decode(
13122            &mut self,
13123            decoder: &mut fidl::encoding::Decoder<'_, D>,
13124            offset: usize,
13125            _depth: fidl::encoding::Depth,
13126        ) -> fidl::Result<()> {
13127            decoder.debug_check_bounds::<Self>(offset);
13128            // Verify that padding bytes are zero.
13129            fidl::decode!(Packet, D, &mut self.packet, decoder, offset + 0, _depth)?;
13130            Ok(())
13131        }
13132    }
13133
13134    impl fidl::encoding::ValueTypeMarker for StreamProcessorRecycleOutputPacketRequest {
13135        type Borrowed<'a> = &'a Self;
13136        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13137            value
13138        }
13139    }
13140
13141    unsafe impl fidl::encoding::TypeMarker for StreamProcessorRecycleOutputPacketRequest {
13142        type Owned = Self;
13143
13144        #[inline(always)]
13145        fn inline_align(_context: fidl::encoding::Context) -> usize {
13146            8
13147        }
13148
13149        #[inline(always)]
13150        fn inline_size(_context: fidl::encoding::Context) -> usize {
13151            16
13152        }
13153    }
13154
13155    unsafe impl<D: fidl::encoding::ResourceDialect>
13156        fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D>
13157        for &StreamProcessorRecycleOutputPacketRequest
13158    {
13159        #[inline]
13160        unsafe fn encode(
13161            self,
13162            encoder: &mut fidl::encoding::Encoder<'_, D>,
13163            offset: usize,
13164            _depth: fidl::encoding::Depth,
13165        ) -> fidl::Result<()> {
13166            encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
13167            // Delegate to tuple encoding.
13168            fidl::encoding::Encode::<StreamProcessorRecycleOutputPacketRequest, D>::encode(
13169                (<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow(
13170                    &self.available_output_packet,
13171                ),),
13172                encoder,
13173                offset,
13174                _depth,
13175            )
13176        }
13177    }
13178    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PacketHeader, D>>
13179        fidl::encoding::Encode<StreamProcessorRecycleOutputPacketRequest, D> for (T0,)
13180    {
13181        #[inline]
13182        unsafe fn encode(
13183            self,
13184            encoder: &mut fidl::encoding::Encoder<'_, D>,
13185            offset: usize,
13186            depth: fidl::encoding::Depth,
13187        ) -> fidl::Result<()> {
13188            encoder.debug_check_bounds::<StreamProcessorRecycleOutputPacketRequest>(offset);
13189            // Zero out padding regions. There's no need to apply masks
13190            // because the unmasked parts will be overwritten by fields.
13191            // Write the fields.
13192            self.0.encode(encoder, offset + 0, depth)?;
13193            Ok(())
13194        }
13195    }
13196
13197    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13198        for StreamProcessorRecycleOutputPacketRequest
13199    {
13200        #[inline(always)]
13201        fn new_empty() -> Self {
13202            Self { available_output_packet: fidl::new_empty!(PacketHeader, D) }
13203        }
13204
13205        #[inline]
13206        unsafe fn decode(
13207            &mut self,
13208            decoder: &mut fidl::encoding::Decoder<'_, D>,
13209            offset: usize,
13210            _depth: fidl::encoding::Depth,
13211        ) -> fidl::Result<()> {
13212            decoder.debug_check_bounds::<Self>(offset);
13213            // Verify that padding bytes are zero.
13214            fidl::decode!(
13215                PacketHeader,
13216                D,
13217                &mut self.available_output_packet,
13218                decoder,
13219                offset + 0,
13220                _depth
13221            )?;
13222            Ok(())
13223        }
13224    }
13225
13226    impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketNoReplyRequest {
13227        type Borrowed<'a> = &'a Self;
13228        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13229            value
13230        }
13231    }
13232
13233    unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketNoReplyRequest {
13234        type Owned = Self;
13235
13236        #[inline(always)]
13237        fn inline_align(_context: fidl::encoding::Context) -> usize {
13238            8
13239        }
13240
13241        #[inline(always)]
13242        fn inline_size(_context: fidl::encoding::Context) -> usize {
13243            56
13244        }
13245    }
13246
13247    unsafe impl<D: fidl::encoding::ResourceDialect>
13248        fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D>
13249        for &StreamSinkSendPacketNoReplyRequest
13250    {
13251        #[inline]
13252        unsafe fn encode(
13253            self,
13254            encoder: &mut fidl::encoding::Encoder<'_, D>,
13255            offset: usize,
13256            _depth: fidl::encoding::Depth,
13257        ) -> fidl::Result<()> {
13258            encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13259            unsafe {
13260                // Copy the object into the buffer.
13261                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13262                (buf_ptr as *mut StreamSinkSendPacketNoReplyRequest)
13263                    .write_unaligned((self as *const StreamSinkSendPacketNoReplyRequest).read());
13264                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13265                // done second because the memcpy will write garbage to these bytes.
13266                let padding_ptr = buf_ptr.offset(8) as *mut u64;
13267                let padding_mask = 0xffffffff00000000u64;
13268                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13269                let padding_ptr = buf_ptr.offset(32) as *mut u64;
13270                let padding_mask = 0xffffffff00000000u64;
13271                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13272            }
13273            Ok(())
13274        }
13275    }
13276    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13277        fidl::encoding::Encode<StreamSinkSendPacketNoReplyRequest, D> for (T0,)
13278    {
13279        #[inline]
13280        unsafe fn encode(
13281            self,
13282            encoder: &mut fidl::encoding::Encoder<'_, D>,
13283            offset: usize,
13284            depth: fidl::encoding::Depth,
13285        ) -> fidl::Result<()> {
13286            encoder.debug_check_bounds::<StreamSinkSendPacketNoReplyRequest>(offset);
13287            // Zero out padding regions. There's no need to apply masks
13288            // because the unmasked parts will be overwritten by fields.
13289            // Write the fields.
13290            self.0.encode(encoder, offset + 0, depth)?;
13291            Ok(())
13292        }
13293    }
13294
13295    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13296        for StreamSinkSendPacketNoReplyRequest
13297    {
13298        #[inline(always)]
13299        fn new_empty() -> Self {
13300            Self { packet: fidl::new_empty!(StreamPacket, D) }
13301        }
13302
13303        #[inline]
13304        unsafe fn decode(
13305            &mut self,
13306            decoder: &mut fidl::encoding::Decoder<'_, D>,
13307            offset: usize,
13308            _depth: fidl::encoding::Depth,
13309        ) -> fidl::Result<()> {
13310            decoder.debug_check_bounds::<Self>(offset);
13311            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13312            // Verify that padding bytes are zero.
13313            let ptr = unsafe { buf_ptr.offset(8) };
13314            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13315            let mask = 0xffffffff00000000u64;
13316            let maskedval = padval & mask;
13317            if maskedval != 0 {
13318                return Err(fidl::Error::NonZeroPadding {
13319                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13320                });
13321            }
13322            let ptr = unsafe { buf_ptr.offset(32) };
13323            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13324            let mask = 0xffffffff00000000u64;
13325            let maskedval = padval & mask;
13326            if maskedval != 0 {
13327                return Err(fidl::Error::NonZeroPadding {
13328                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13329                });
13330            }
13331            // Copy from the buffer into the object.
13332            unsafe {
13333                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13334            }
13335            Ok(())
13336        }
13337    }
13338
13339    impl fidl::encoding::ValueTypeMarker for StreamSinkSendPacketRequest {
13340        type Borrowed<'a> = &'a Self;
13341        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13342            value
13343        }
13344    }
13345
13346    unsafe impl fidl::encoding::TypeMarker for StreamSinkSendPacketRequest {
13347        type Owned = Self;
13348
13349        #[inline(always)]
13350        fn inline_align(_context: fidl::encoding::Context) -> usize {
13351            8
13352        }
13353
13354        #[inline(always)]
13355        fn inline_size(_context: fidl::encoding::Context) -> usize {
13356            56
13357        }
13358    }
13359
13360    unsafe impl<D: fidl::encoding::ResourceDialect>
13361        fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for &StreamSinkSendPacketRequest
13362    {
13363        #[inline]
13364        unsafe fn encode(
13365            self,
13366            encoder: &mut fidl::encoding::Encoder<'_, D>,
13367            offset: usize,
13368            _depth: fidl::encoding::Depth,
13369        ) -> fidl::Result<()> {
13370            encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13371            unsafe {
13372                // Copy the object into the buffer.
13373                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13374                (buf_ptr as *mut StreamSinkSendPacketRequest)
13375                    .write_unaligned((self as *const StreamSinkSendPacketRequest).read());
13376                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13377                // done second because the memcpy will write garbage to these bytes.
13378                let padding_ptr = buf_ptr.offset(8) as *mut u64;
13379                let padding_mask = 0xffffffff00000000u64;
13380                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13381                let padding_ptr = buf_ptr.offset(32) as *mut u64;
13382                let padding_mask = 0xffffffff00000000u64;
13383                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13384            }
13385            Ok(())
13386        }
13387    }
13388    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13389        fidl::encoding::Encode<StreamSinkSendPacketRequest, D> for (T0,)
13390    {
13391        #[inline]
13392        unsafe fn encode(
13393            self,
13394            encoder: &mut fidl::encoding::Encoder<'_, D>,
13395            offset: usize,
13396            depth: fidl::encoding::Depth,
13397        ) -> fidl::Result<()> {
13398            encoder.debug_check_bounds::<StreamSinkSendPacketRequest>(offset);
13399            // Zero out padding regions. There's no need to apply masks
13400            // because the unmasked parts will be overwritten by fields.
13401            // Write the fields.
13402            self.0.encode(encoder, offset + 0, depth)?;
13403            Ok(())
13404        }
13405    }
13406
13407    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13408        for StreamSinkSendPacketRequest
13409    {
13410        #[inline(always)]
13411        fn new_empty() -> Self {
13412            Self { packet: fidl::new_empty!(StreamPacket, D) }
13413        }
13414
13415        #[inline]
13416        unsafe fn decode(
13417            &mut self,
13418            decoder: &mut fidl::encoding::Decoder<'_, D>,
13419            offset: usize,
13420            _depth: fidl::encoding::Depth,
13421        ) -> fidl::Result<()> {
13422            decoder.debug_check_bounds::<Self>(offset);
13423            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13424            // Verify that padding bytes are zero.
13425            let ptr = unsafe { buf_ptr.offset(8) };
13426            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13427            let mask = 0xffffffff00000000u64;
13428            let maskedval = padval & mask;
13429            if maskedval != 0 {
13430                return Err(fidl::Error::NonZeroPadding {
13431                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13432                });
13433            }
13434            let ptr = unsafe { buf_ptr.offset(32) };
13435            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13436            let mask = 0xffffffff00000000u64;
13437            let maskedval = padval & mask;
13438            if maskedval != 0 {
13439                return Err(fidl::Error::NonZeroPadding {
13440                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13441                });
13442            }
13443            // Copy from the buffer into the object.
13444            unsafe {
13445                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13446            }
13447            Ok(())
13448        }
13449    }
13450
13451    impl fidl::encoding::ValueTypeMarker for StreamSourceOnPacketProducedRequest {
13452        type Borrowed<'a> = &'a Self;
13453        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13454            value
13455        }
13456    }
13457
13458    unsafe impl fidl::encoding::TypeMarker for StreamSourceOnPacketProducedRequest {
13459        type Owned = Self;
13460
13461        #[inline(always)]
13462        fn inline_align(_context: fidl::encoding::Context) -> usize {
13463            8
13464        }
13465
13466        #[inline(always)]
13467        fn inline_size(_context: fidl::encoding::Context) -> usize {
13468            56
13469        }
13470    }
13471
13472    unsafe impl<D: fidl::encoding::ResourceDialect>
13473        fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D>
13474        for &StreamSourceOnPacketProducedRequest
13475    {
13476        #[inline]
13477        unsafe fn encode(
13478            self,
13479            encoder: &mut fidl::encoding::Encoder<'_, D>,
13480            offset: usize,
13481            _depth: fidl::encoding::Depth,
13482        ) -> fidl::Result<()> {
13483            encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13484            unsafe {
13485                // Copy the object into the buffer.
13486                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13487                (buf_ptr as *mut StreamSourceOnPacketProducedRequest)
13488                    .write_unaligned((self as *const StreamSourceOnPacketProducedRequest).read());
13489                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13490                // done second because the memcpy will write garbage to these bytes.
13491                let padding_ptr = buf_ptr.offset(8) as *mut u64;
13492                let padding_mask = 0xffffffff00000000u64;
13493                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13494                let padding_ptr = buf_ptr.offset(32) as *mut u64;
13495                let padding_mask = 0xffffffff00000000u64;
13496                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13497            }
13498            Ok(())
13499        }
13500    }
13501    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13502        fidl::encoding::Encode<StreamSourceOnPacketProducedRequest, D> for (T0,)
13503    {
13504        #[inline]
13505        unsafe fn encode(
13506            self,
13507            encoder: &mut fidl::encoding::Encoder<'_, D>,
13508            offset: usize,
13509            depth: fidl::encoding::Depth,
13510        ) -> fidl::Result<()> {
13511            encoder.debug_check_bounds::<StreamSourceOnPacketProducedRequest>(offset);
13512            // Zero out padding regions. There's no need to apply masks
13513            // because the unmasked parts will be overwritten by fields.
13514            // Write the fields.
13515            self.0.encode(encoder, offset + 0, depth)?;
13516            Ok(())
13517        }
13518    }
13519
13520    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13521        for StreamSourceOnPacketProducedRequest
13522    {
13523        #[inline(always)]
13524        fn new_empty() -> Self {
13525            Self { packet: fidl::new_empty!(StreamPacket, D) }
13526        }
13527
13528        #[inline]
13529        unsafe fn decode(
13530            &mut self,
13531            decoder: &mut fidl::encoding::Decoder<'_, D>,
13532            offset: usize,
13533            _depth: fidl::encoding::Depth,
13534        ) -> fidl::Result<()> {
13535            decoder.debug_check_bounds::<Self>(offset);
13536            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13537            // Verify that padding bytes are zero.
13538            let ptr = unsafe { buf_ptr.offset(8) };
13539            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13540            let mask = 0xffffffff00000000u64;
13541            let maskedval = padval & mask;
13542            if maskedval != 0 {
13543                return Err(fidl::Error::NonZeroPadding {
13544                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13545                });
13546            }
13547            let ptr = unsafe { buf_ptr.offset(32) };
13548            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13549            let mask = 0xffffffff00000000u64;
13550            let maskedval = padval & mask;
13551            if maskedval != 0 {
13552                return Err(fidl::Error::NonZeroPadding {
13553                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13554                });
13555            }
13556            // Copy from the buffer into the object.
13557            unsafe {
13558                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13559            }
13560            Ok(())
13561        }
13562    }
13563
13564    impl fidl::encoding::ValueTypeMarker for StreamSourceReleasePacketRequest {
13565        type Borrowed<'a> = &'a Self;
13566        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13567            value
13568        }
13569    }
13570
13571    unsafe impl fidl::encoding::TypeMarker for StreamSourceReleasePacketRequest {
13572        type Owned = Self;
13573
13574        #[inline(always)]
13575        fn inline_align(_context: fidl::encoding::Context) -> usize {
13576            8
13577        }
13578
13579        #[inline(always)]
13580        fn inline_size(_context: fidl::encoding::Context) -> usize {
13581            56
13582        }
13583    }
13584
13585    unsafe impl<D: fidl::encoding::ResourceDialect>
13586        fidl::encoding::Encode<StreamSourceReleasePacketRequest, D>
13587        for &StreamSourceReleasePacketRequest
13588    {
13589        #[inline]
13590        unsafe fn encode(
13591            self,
13592            encoder: &mut fidl::encoding::Encoder<'_, D>,
13593            offset: usize,
13594            _depth: fidl::encoding::Depth,
13595        ) -> fidl::Result<()> {
13596            encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13597            unsafe {
13598                // Copy the object into the buffer.
13599                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13600                (buf_ptr as *mut StreamSourceReleasePacketRequest)
13601                    .write_unaligned((self as *const StreamSourceReleasePacketRequest).read());
13602                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13603                // done second because the memcpy will write garbage to these bytes.
13604                let padding_ptr = buf_ptr.offset(8) as *mut u64;
13605                let padding_mask = 0xffffffff00000000u64;
13606                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13607                let padding_ptr = buf_ptr.offset(32) as *mut u64;
13608                let padding_mask = 0xffffffff00000000u64;
13609                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
13610            }
13611            Ok(())
13612        }
13613    }
13614    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StreamPacket, D>>
13615        fidl::encoding::Encode<StreamSourceReleasePacketRequest, D> for (T0,)
13616    {
13617        #[inline]
13618        unsafe fn encode(
13619            self,
13620            encoder: &mut fidl::encoding::Encoder<'_, D>,
13621            offset: usize,
13622            depth: fidl::encoding::Depth,
13623        ) -> fidl::Result<()> {
13624            encoder.debug_check_bounds::<StreamSourceReleasePacketRequest>(offset);
13625            // Zero out padding regions. There's no need to apply masks
13626            // because the unmasked parts will be overwritten by fields.
13627            // Write the fields.
13628            self.0.encode(encoder, offset + 0, depth)?;
13629            Ok(())
13630        }
13631    }
13632
13633    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13634        for StreamSourceReleasePacketRequest
13635    {
13636        #[inline(always)]
13637        fn new_empty() -> Self {
13638            Self { packet: fidl::new_empty!(StreamPacket, D) }
13639        }
13640
13641        #[inline]
13642        unsafe fn decode(
13643            &mut self,
13644            decoder: &mut fidl::encoding::Decoder<'_, D>,
13645            offset: usize,
13646            _depth: fidl::encoding::Depth,
13647        ) -> fidl::Result<()> {
13648            decoder.debug_check_bounds::<Self>(offset);
13649            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13650            // Verify that padding bytes are zero.
13651            let ptr = unsafe { buf_ptr.offset(8) };
13652            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13653            let mask = 0xffffffff00000000u64;
13654            let maskedval = padval & mask;
13655            if maskedval != 0 {
13656                return Err(fidl::Error::NonZeroPadding {
13657                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
13658                });
13659            }
13660            let ptr = unsafe { buf_ptr.offset(32) };
13661            let padval = unsafe { (ptr as *const u64).read_unaligned() };
13662            let mask = 0xffffffff00000000u64;
13663            let maskedval = padval & mask;
13664            if maskedval != 0 {
13665                return Err(fidl::Error::NonZeroPadding {
13666                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
13667                });
13668            }
13669            // Copy from the buffer into the object.
13670            unsafe {
13671                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
13672            }
13673            Ok(())
13674        }
13675    }
13676
13677    impl fidl::encoding::ValueTypeMarker for StreamType {
13678        type Borrowed<'a> = &'a Self;
13679        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13680            value
13681        }
13682    }
13683
13684    unsafe impl fidl::encoding::TypeMarker for StreamType {
13685        type Owned = Self;
13686
13687        #[inline(always)]
13688        fn inline_align(_context: fidl::encoding::Context) -> usize {
13689            8
13690        }
13691
13692        #[inline(always)]
13693        fn inline_size(_context: fidl::encoding::Context) -> usize {
13694            48
13695        }
13696    }
13697
13698    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamType, D>
13699        for &StreamType
13700    {
13701        #[inline]
13702        unsafe fn encode(
13703            self,
13704            encoder: &mut fidl::encoding::Encoder<'_, D>,
13705            offset: usize,
13706            _depth: fidl::encoding::Depth,
13707        ) -> fidl::Result<()> {
13708            encoder.debug_check_bounds::<StreamType>(offset);
13709            // Delegate to tuple encoding.
13710            fidl::encoding::Encode::<StreamType, D>::encode(
13711                (
13712                    <MediumSpecificStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.medium_specific),
13713                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding),
13714                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>> as fidl::encoding::ValueTypeMarker>::borrow(&self.encoding_parameters),
13715                ),
13716                encoder, offset, _depth
13717            )
13718        }
13719    }
13720    unsafe impl<
13721            D: fidl::encoding::ResourceDialect,
13722            T0: fidl::encoding::Encode<MediumSpecificStreamType, D>,
13723            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
13724            T2: fidl::encoding::Encode<
13725                fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13726                D,
13727            >,
13728        > fidl::encoding::Encode<StreamType, D> for (T0, T1, T2)
13729    {
13730        #[inline]
13731        unsafe fn encode(
13732            self,
13733            encoder: &mut fidl::encoding::Encoder<'_, D>,
13734            offset: usize,
13735            depth: fidl::encoding::Depth,
13736        ) -> fidl::Result<()> {
13737            encoder.debug_check_bounds::<StreamType>(offset);
13738            // Zero out padding regions. There's no need to apply masks
13739            // because the unmasked parts will be overwritten by fields.
13740            // Write the fields.
13741            self.0.encode(encoder, offset + 0, depth)?;
13742            self.1.encode(encoder, offset + 16, depth)?;
13743            self.2.encode(encoder, offset + 32, depth)?;
13744            Ok(())
13745        }
13746    }
13747
13748    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamType {
13749        #[inline(always)]
13750        fn new_empty() -> Self {
13751            Self {
13752                medium_specific: fidl::new_empty!(MediumSpecificStreamType, D),
13753                encoding: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
13754                encoding_parameters: fidl::new_empty!(
13755                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13756                    D
13757                ),
13758            }
13759        }
13760
13761        #[inline]
13762        unsafe fn decode(
13763            &mut self,
13764            decoder: &mut fidl::encoding::Decoder<'_, D>,
13765            offset: usize,
13766            _depth: fidl::encoding::Depth,
13767        ) -> fidl::Result<()> {
13768            decoder.debug_check_bounds::<Self>(offset);
13769            // Verify that padding bytes are zero.
13770            fidl::decode!(
13771                MediumSpecificStreamType,
13772                D,
13773                &mut self.medium_specific,
13774                decoder,
13775                offset + 0,
13776                _depth
13777            )?;
13778            fidl::decode!(
13779                fidl::encoding::BoundedString<255>,
13780                D,
13781                &mut self.encoding,
13782                decoder,
13783                offset + 16,
13784                _depth
13785            )?;
13786            fidl::decode!(
13787                fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
13788                D,
13789                &mut self.encoding_parameters,
13790                decoder,
13791                offset + 32,
13792                _depth
13793            )?;
13794            Ok(())
13795        }
13796    }
13797
13798    impl fidl::encoding::ValueTypeMarker for SubpictureStreamType {
13799        type Borrowed<'a> = &'a Self;
13800        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13801            value
13802        }
13803    }
13804
13805    unsafe impl fidl::encoding::TypeMarker for SubpictureStreamType {
13806        type Owned = Self;
13807
13808        #[inline(always)]
13809        fn inline_align(_context: fidl::encoding::Context) -> usize {
13810            1
13811        }
13812
13813        #[inline(always)]
13814        fn inline_size(_context: fidl::encoding::Context) -> usize {
13815            1
13816        }
13817    }
13818
13819    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubpictureStreamType, D>
13820        for &SubpictureStreamType
13821    {
13822        #[inline]
13823        unsafe fn encode(
13824            self,
13825            encoder: &mut fidl::encoding::Encoder<'_, D>,
13826            offset: usize,
13827            _depth: fidl::encoding::Depth,
13828        ) -> fidl::Result<()> {
13829            encoder.debug_check_bounds::<SubpictureStreamType>(offset);
13830            encoder.write_num(0u8, offset);
13831            Ok(())
13832        }
13833    }
13834
13835    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubpictureStreamType {
13836        #[inline(always)]
13837        fn new_empty() -> Self {
13838            Self
13839        }
13840
13841        #[inline]
13842        unsafe fn decode(
13843            &mut self,
13844            decoder: &mut fidl::encoding::Decoder<'_, D>,
13845            offset: usize,
13846            _depth: fidl::encoding::Depth,
13847        ) -> fidl::Result<()> {
13848            decoder.debug_check_bounds::<Self>(offset);
13849            match decoder.read_num::<u8>(offset) {
13850                0 => Ok(()),
13851                _ => Err(fidl::Error::Invalid),
13852            }
13853        }
13854    }
13855
13856    impl fidl::encoding::ValueTypeMarker for SubsampleEntry {
13857        type Borrowed<'a> = &'a Self;
13858        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13859            value
13860        }
13861    }
13862
13863    unsafe impl fidl::encoding::TypeMarker for SubsampleEntry {
13864        type Owned = Self;
13865
13866        #[inline(always)]
13867        fn inline_align(_context: fidl::encoding::Context) -> usize {
13868            4
13869        }
13870
13871        #[inline(always)]
13872        fn inline_size(_context: fidl::encoding::Context) -> usize {
13873            8
13874        }
13875        #[inline(always)]
13876        fn encode_is_copy() -> bool {
13877            true
13878        }
13879
13880        #[inline(always)]
13881        fn decode_is_copy() -> bool {
13882            true
13883        }
13884    }
13885
13886    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubsampleEntry, D>
13887        for &SubsampleEntry
13888    {
13889        #[inline]
13890        unsafe fn encode(
13891            self,
13892            encoder: &mut fidl::encoding::Encoder<'_, D>,
13893            offset: usize,
13894            _depth: fidl::encoding::Depth,
13895        ) -> fidl::Result<()> {
13896            encoder.debug_check_bounds::<SubsampleEntry>(offset);
13897            unsafe {
13898                // Copy the object into the buffer.
13899                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13900                (buf_ptr as *mut SubsampleEntry)
13901                    .write_unaligned((self as *const SubsampleEntry).read());
13902                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13903                // done second because the memcpy will write garbage to these bytes.
13904            }
13905            Ok(())
13906        }
13907    }
13908    unsafe impl<
13909            D: fidl::encoding::ResourceDialect,
13910            T0: fidl::encoding::Encode<u32, D>,
13911            T1: fidl::encoding::Encode<u32, D>,
13912        > fidl::encoding::Encode<SubsampleEntry, D> for (T0, T1)
13913    {
13914        #[inline]
13915        unsafe fn encode(
13916            self,
13917            encoder: &mut fidl::encoding::Encoder<'_, D>,
13918            offset: usize,
13919            depth: fidl::encoding::Depth,
13920        ) -> fidl::Result<()> {
13921            encoder.debug_check_bounds::<SubsampleEntry>(offset);
13922            // Zero out padding regions. There's no need to apply masks
13923            // because the unmasked parts will be overwritten by fields.
13924            // Write the fields.
13925            self.0.encode(encoder, offset + 0, depth)?;
13926            self.1.encode(encoder, offset + 4, depth)?;
13927            Ok(())
13928        }
13929    }
13930
13931    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubsampleEntry {
13932        #[inline(always)]
13933        fn new_empty() -> Self {
13934            Self {
13935                clear_bytes: fidl::new_empty!(u32, D),
13936                encrypted_bytes: fidl::new_empty!(u32, D),
13937            }
13938        }
13939
13940        #[inline]
13941        unsafe fn decode(
13942            &mut self,
13943            decoder: &mut fidl::encoding::Decoder<'_, D>,
13944            offset: usize,
13945            _depth: fidl::encoding::Depth,
13946        ) -> fidl::Result<()> {
13947            decoder.debug_check_bounds::<Self>(offset);
13948            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13949            // Verify that padding bytes are zero.
13950            // Copy from the buffer into the object.
13951            unsafe {
13952                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
13953            }
13954            Ok(())
13955        }
13956    }
13957
13958    impl fidl::encoding::ValueTypeMarker for TextStreamType {
13959        type Borrowed<'a> = &'a Self;
13960        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13961            value
13962        }
13963    }
13964
13965    unsafe impl fidl::encoding::TypeMarker for TextStreamType {
13966        type Owned = Self;
13967
13968        #[inline(always)]
13969        fn inline_align(_context: fidl::encoding::Context) -> usize {
13970            1
13971        }
13972
13973        #[inline(always)]
13974        fn inline_size(_context: fidl::encoding::Context) -> usize {
13975            1
13976        }
13977    }
13978
13979    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TextStreamType, D>
13980        for &TextStreamType
13981    {
13982        #[inline]
13983        unsafe fn encode(
13984            self,
13985            encoder: &mut fidl::encoding::Encoder<'_, D>,
13986            offset: usize,
13987            _depth: fidl::encoding::Depth,
13988        ) -> fidl::Result<()> {
13989            encoder.debug_check_bounds::<TextStreamType>(offset);
13990            encoder.write_num(0u8, offset);
13991            Ok(())
13992        }
13993    }
13994
13995    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TextStreamType {
13996        #[inline(always)]
13997        fn new_empty() -> Self {
13998            Self
13999        }
14000
14001        #[inline]
14002        unsafe fn decode(
14003            &mut self,
14004            decoder: &mut fidl::encoding::Decoder<'_, D>,
14005            offset: usize,
14006            _depth: fidl::encoding::Depth,
14007        ) -> fidl::Result<()> {
14008            decoder.debug_check_bounds::<Self>(offset);
14009            match decoder.read_num::<u8>(offset) {
14010                0 => Ok(()),
14011                _ => Err(fidl::Error::Invalid),
14012            }
14013        }
14014    }
14015
14016    impl fidl::encoding::ValueTypeMarker for TimelineFunction {
14017        type Borrowed<'a> = &'a Self;
14018        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14019            value
14020        }
14021    }
14022
14023    unsafe impl fidl::encoding::TypeMarker for TimelineFunction {
14024        type Owned = Self;
14025
14026        #[inline(always)]
14027        fn inline_align(_context: fidl::encoding::Context) -> usize {
14028            8
14029        }
14030
14031        #[inline(always)]
14032        fn inline_size(_context: fidl::encoding::Context) -> usize {
14033            24
14034        }
14035        #[inline(always)]
14036        fn encode_is_copy() -> bool {
14037            true
14038        }
14039
14040        #[inline(always)]
14041        fn decode_is_copy() -> bool {
14042            true
14043        }
14044    }
14045
14046    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TimelineFunction, D>
14047        for &TimelineFunction
14048    {
14049        #[inline]
14050        unsafe fn encode(
14051            self,
14052            encoder: &mut fidl::encoding::Encoder<'_, D>,
14053            offset: usize,
14054            _depth: fidl::encoding::Depth,
14055        ) -> fidl::Result<()> {
14056            encoder.debug_check_bounds::<TimelineFunction>(offset);
14057            unsafe {
14058                // Copy the object into the buffer.
14059                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
14060                (buf_ptr as *mut TimelineFunction)
14061                    .write_unaligned((self as *const TimelineFunction).read());
14062                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
14063                // done second because the memcpy will write garbage to these bytes.
14064            }
14065            Ok(())
14066        }
14067    }
14068    unsafe impl<
14069            D: fidl::encoding::ResourceDialect,
14070            T0: fidl::encoding::Encode<i64, D>,
14071            T1: fidl::encoding::Encode<i64, D>,
14072            T2: fidl::encoding::Encode<u32, D>,
14073            T3: fidl::encoding::Encode<u32, D>,
14074        > fidl::encoding::Encode<TimelineFunction, D> for (T0, T1, T2, T3)
14075    {
14076        #[inline]
14077        unsafe fn encode(
14078            self,
14079            encoder: &mut fidl::encoding::Encoder<'_, D>,
14080            offset: usize,
14081            depth: fidl::encoding::Depth,
14082        ) -> fidl::Result<()> {
14083            encoder.debug_check_bounds::<TimelineFunction>(offset);
14084            // Zero out padding regions. There's no need to apply masks
14085            // because the unmasked parts will be overwritten by fields.
14086            // Write the fields.
14087            self.0.encode(encoder, offset + 0, depth)?;
14088            self.1.encode(encoder, offset + 8, depth)?;
14089            self.2.encode(encoder, offset + 16, depth)?;
14090            self.3.encode(encoder, offset + 20, depth)?;
14091            Ok(())
14092        }
14093    }
14094
14095    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TimelineFunction {
14096        #[inline(always)]
14097        fn new_empty() -> Self {
14098            Self {
14099                subject_time: fidl::new_empty!(i64, D),
14100                reference_time: fidl::new_empty!(i64, D),
14101                subject_delta: fidl::new_empty!(u32, D),
14102                reference_delta: fidl::new_empty!(u32, D),
14103            }
14104        }
14105
14106        #[inline]
14107        unsafe fn decode(
14108            &mut self,
14109            decoder: &mut fidl::encoding::Decoder<'_, D>,
14110            offset: usize,
14111            _depth: fidl::encoding::Depth,
14112        ) -> fidl::Result<()> {
14113            decoder.debug_check_bounds::<Self>(offset);
14114            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
14115            // Verify that padding bytes are zero.
14116            // Copy from the buffer into the object.
14117            unsafe {
14118                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
14119            }
14120            Ok(())
14121        }
14122    }
14123
14124    impl fidl::encoding::ValueTypeMarker for UsageGainListenerOnGainMuteChangedRequest {
14125        type Borrowed<'a> = &'a Self;
14126        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14127            value
14128        }
14129    }
14130
14131    unsafe impl fidl::encoding::TypeMarker for UsageGainListenerOnGainMuteChangedRequest {
14132        type Owned = Self;
14133
14134        #[inline(always)]
14135        fn inline_align(_context: fidl::encoding::Context) -> usize {
14136            4
14137        }
14138
14139        #[inline(always)]
14140        fn inline_size(_context: fidl::encoding::Context) -> usize {
14141            8
14142        }
14143    }
14144
14145    unsafe impl<D: fidl::encoding::ResourceDialect>
14146        fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D>
14147        for &UsageGainListenerOnGainMuteChangedRequest
14148    {
14149        #[inline]
14150        unsafe fn encode(
14151            self,
14152            encoder: &mut fidl::encoding::Encoder<'_, D>,
14153            offset: usize,
14154            _depth: fidl::encoding::Depth,
14155        ) -> fidl::Result<()> {
14156            encoder.debug_check_bounds::<UsageGainListenerOnGainMuteChangedRequest>(offset);
14157            // Delegate to tuple encoding.
14158            fidl::encoding::Encode::<UsageGainListenerOnGainMuteChangedRequest, D>::encode(
14159                (
14160                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.muted),
14161                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.gain_dbfs),
14162                ),
14163                encoder,
14164                offset,
14165                _depth,
14166            )
14167        }
14168    }
14169    unsafe impl<
14170            D: fidl::encoding::ResourceDialect,
14171            T0: fidl::encoding::Encode<bool, D>,
14172            T1: fidl::encoding::Encode<f32, D>,
14173        > fidl::encoding::Encode<UsageGainListenerOnGainMuteChangedRequest, D> for (T0, T1)
14174    {
14175        #[inline]
14176        unsafe fn encode(
14177            self,
14178            encoder: &mut fidl::encoding::Encoder<'_, D>,
14179            offset: usize,
14180            depth: fidl::encoding::Depth,
14181        ) -> fidl::Result<()> {
14182            encoder.debug_check_bounds::<UsageGainListenerOnGainMuteChangedRequest>(offset);
14183            // Zero out padding regions. There's no need to apply masks
14184            // because the unmasked parts will be overwritten by fields.
14185            unsafe {
14186                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
14187                (ptr as *mut u32).write_unaligned(0);
14188            }
14189            // Write the fields.
14190            self.0.encode(encoder, offset + 0, depth)?;
14191            self.1.encode(encoder, offset + 4, depth)?;
14192            Ok(())
14193        }
14194    }
14195
14196    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14197        for UsageGainListenerOnGainMuteChangedRequest
14198    {
14199        #[inline(always)]
14200        fn new_empty() -> Self {
14201            Self { muted: fidl::new_empty!(bool, D), gain_dbfs: fidl::new_empty!(f32, D) }
14202        }
14203
14204        #[inline]
14205        unsafe fn decode(
14206            &mut self,
14207            decoder: &mut fidl::encoding::Decoder<'_, D>,
14208            offset: usize,
14209            _depth: fidl::encoding::Depth,
14210        ) -> fidl::Result<()> {
14211            decoder.debug_check_bounds::<Self>(offset);
14212            // Verify that padding bytes are zero.
14213            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
14214            let padval = unsafe { (ptr as *const u32).read_unaligned() };
14215            let mask = 0xffffff00u32;
14216            let maskedval = padval & mask;
14217            if maskedval != 0 {
14218                return Err(fidl::Error::NonZeroPadding {
14219                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
14220                });
14221            }
14222            fidl::decode!(bool, D, &mut self.muted, decoder, offset + 0, _depth)?;
14223            fidl::decode!(f32, D, &mut self.gain_dbfs, decoder, offset + 4, _depth)?;
14224            Ok(())
14225        }
14226    }
14227
14228    impl fidl::encoding::ValueTypeMarker for UsageWatcher2OnStateChangedRequest {
14229        type Borrowed<'a> = &'a Self;
14230        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14231            value
14232        }
14233    }
14234
14235    unsafe impl fidl::encoding::TypeMarker for UsageWatcher2OnStateChangedRequest {
14236        type Owned = Self;
14237
14238        #[inline(always)]
14239        fn inline_align(_context: fidl::encoding::Context) -> usize {
14240            8
14241        }
14242
14243        #[inline(always)]
14244        fn inline_size(_context: fidl::encoding::Context) -> usize {
14245            32
14246        }
14247    }
14248
14249    unsafe impl<D: fidl::encoding::ResourceDialect>
14250        fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D>
14251        for &UsageWatcher2OnStateChangedRequest
14252    {
14253        #[inline]
14254        unsafe fn encode(
14255            self,
14256            encoder: &mut fidl::encoding::Encoder<'_, D>,
14257            offset: usize,
14258            _depth: fidl::encoding::Depth,
14259        ) -> fidl::Result<()> {
14260            encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14261            // Delegate to tuple encoding.
14262            fidl::encoding::Encode::<UsageWatcher2OnStateChangedRequest, D>::encode(
14263                (
14264                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14265                    <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14266                ),
14267                encoder,
14268                offset,
14269                _depth,
14270            )
14271        }
14272    }
14273    unsafe impl<
14274            D: fidl::encoding::ResourceDialect,
14275            T0: fidl::encoding::Encode<Usage2, D>,
14276            T1: fidl::encoding::Encode<UsageState, D>,
14277        > fidl::encoding::Encode<UsageWatcher2OnStateChangedRequest, D> for (T0, T1)
14278    {
14279        #[inline]
14280        unsafe fn encode(
14281            self,
14282            encoder: &mut fidl::encoding::Encoder<'_, D>,
14283            offset: usize,
14284            depth: fidl::encoding::Depth,
14285        ) -> fidl::Result<()> {
14286            encoder.debug_check_bounds::<UsageWatcher2OnStateChangedRequest>(offset);
14287            // 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 + 16, depth)?;
14292            Ok(())
14293        }
14294    }
14295
14296    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14297        for UsageWatcher2OnStateChangedRequest
14298    {
14299        #[inline(always)]
14300        fn new_empty() -> Self {
14301            Self { usage: fidl::new_empty!(Usage2, D), state: fidl::new_empty!(UsageState, D) }
14302        }
14303
14304        #[inline]
14305        unsafe fn decode(
14306            &mut self,
14307            decoder: &mut fidl::encoding::Decoder<'_, D>,
14308            offset: usize,
14309            _depth: fidl::encoding::Depth,
14310        ) -> fidl::Result<()> {
14311            decoder.debug_check_bounds::<Self>(offset);
14312            // Verify that padding bytes are zero.
14313            fidl::decode!(Usage2, D, &mut self.usage, decoder, offset + 0, _depth)?;
14314            fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14315            Ok(())
14316        }
14317    }
14318
14319    impl fidl::encoding::ValueTypeMarker for UsageWatcherOnStateChangedRequest {
14320        type Borrowed<'a> = &'a Self;
14321        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14322            value
14323        }
14324    }
14325
14326    unsafe impl fidl::encoding::TypeMarker for UsageWatcherOnStateChangedRequest {
14327        type Owned = Self;
14328
14329        #[inline(always)]
14330        fn inline_align(_context: fidl::encoding::Context) -> usize {
14331            8
14332        }
14333
14334        #[inline(always)]
14335        fn inline_size(_context: fidl::encoding::Context) -> usize {
14336            32
14337        }
14338    }
14339
14340    unsafe impl<D: fidl::encoding::ResourceDialect>
14341        fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D>
14342        for &UsageWatcherOnStateChangedRequest
14343    {
14344        #[inline]
14345        unsafe fn encode(
14346            self,
14347            encoder: &mut fidl::encoding::Encoder<'_, D>,
14348            offset: usize,
14349            _depth: fidl::encoding::Depth,
14350        ) -> fidl::Result<()> {
14351            encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14352            // Delegate to tuple encoding.
14353            fidl::encoding::Encode::<UsageWatcherOnStateChangedRequest, D>::encode(
14354                (
14355                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
14356                    <UsageState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
14357                ),
14358                encoder,
14359                offset,
14360                _depth,
14361            )
14362        }
14363    }
14364    unsafe impl<
14365            D: fidl::encoding::ResourceDialect,
14366            T0: fidl::encoding::Encode<Usage, D>,
14367            T1: fidl::encoding::Encode<UsageState, D>,
14368        > fidl::encoding::Encode<UsageWatcherOnStateChangedRequest, D> for (T0, T1)
14369    {
14370        #[inline]
14371        unsafe fn encode(
14372            self,
14373            encoder: &mut fidl::encoding::Encoder<'_, D>,
14374            offset: usize,
14375            depth: fidl::encoding::Depth,
14376        ) -> fidl::Result<()> {
14377            encoder.debug_check_bounds::<UsageWatcherOnStateChangedRequest>(offset);
14378            // Zero out padding regions. There's no need to apply masks
14379            // because the unmasked parts will be overwritten by fields.
14380            // Write the fields.
14381            self.0.encode(encoder, offset + 0, depth)?;
14382            self.1.encode(encoder, offset + 16, depth)?;
14383            Ok(())
14384        }
14385    }
14386
14387    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14388        for UsageWatcherOnStateChangedRequest
14389    {
14390        #[inline(always)]
14391        fn new_empty() -> Self {
14392            Self { usage: fidl::new_empty!(Usage, D), state: fidl::new_empty!(UsageState, D) }
14393        }
14394
14395        #[inline]
14396        unsafe fn decode(
14397            &mut self,
14398            decoder: &mut fidl::encoding::Decoder<'_, D>,
14399            offset: usize,
14400            _depth: fidl::encoding::Depth,
14401        ) -> fidl::Result<()> {
14402            decoder.debug_check_bounds::<Self>(offset);
14403            // Verify that padding bytes are zero.
14404            fidl::decode!(Usage, D, &mut self.usage, decoder, offset + 0, _depth)?;
14405            fidl::decode!(UsageState, D, &mut self.state, decoder, offset + 16, _depth)?;
14406            Ok(())
14407        }
14408    }
14409
14410    impl fidl::encoding::ValueTypeMarker for VideoStreamType {
14411        type Borrowed<'a> = &'a Self;
14412        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14413            value
14414        }
14415    }
14416
14417    unsafe impl fidl::encoding::TypeMarker for VideoStreamType {
14418        type Owned = Self;
14419
14420        #[inline(always)]
14421        fn inline_align(_context: fidl::encoding::Context) -> usize {
14422            4
14423        }
14424
14425        #[inline(always)]
14426        fn inline_size(_context: fidl::encoding::Context) -> usize {
14427            36
14428        }
14429    }
14430
14431    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoStreamType, D>
14432        for &VideoStreamType
14433    {
14434        #[inline]
14435        unsafe fn encode(
14436            self,
14437            encoder: &mut fidl::encoding::Encoder<'_, D>,
14438            offset: usize,
14439            _depth: fidl::encoding::Depth,
14440        ) -> fidl::Result<()> {
14441            encoder.debug_check_bounds::<VideoStreamType>(offset);
14442            // Delegate to tuple encoding.
14443            fidl::encoding::Encode::<VideoStreamType, D>::encode(
14444                (
14445                    <fidl_fuchsia_images__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
14446                    <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
14447                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
14448                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
14449                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_width),
14450                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_height),
14451                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14452                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14453                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.stride),
14454                ),
14455                encoder, offset, _depth
14456            )
14457        }
14458    }
14459    unsafe impl<
14460            D: fidl::encoding::ResourceDialect,
14461            T0: fidl::encoding::Encode<fidl_fuchsia_images__common::PixelFormat, D>,
14462            T1: fidl::encoding::Encode<ColorSpace, D>,
14463            T2: fidl::encoding::Encode<u32, D>,
14464            T3: fidl::encoding::Encode<u32, D>,
14465            T4: fidl::encoding::Encode<u32, D>,
14466            T5: fidl::encoding::Encode<u32, D>,
14467            T6: fidl::encoding::Encode<u32, D>,
14468            T7: fidl::encoding::Encode<u32, D>,
14469            T8: fidl::encoding::Encode<u32, D>,
14470        > fidl::encoding::Encode<VideoStreamType, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
14471    {
14472        #[inline]
14473        unsafe fn encode(
14474            self,
14475            encoder: &mut fidl::encoding::Encoder<'_, D>,
14476            offset: usize,
14477            depth: fidl::encoding::Depth,
14478        ) -> fidl::Result<()> {
14479            encoder.debug_check_bounds::<VideoStreamType>(offset);
14480            // Zero out padding regions. There's no need to apply masks
14481            // because the unmasked parts will be overwritten by fields.
14482            // Write the fields.
14483            self.0.encode(encoder, offset + 0, depth)?;
14484            self.1.encode(encoder, offset + 4, depth)?;
14485            self.2.encode(encoder, offset + 8, depth)?;
14486            self.3.encode(encoder, offset + 12, depth)?;
14487            self.4.encode(encoder, offset + 16, depth)?;
14488            self.5.encode(encoder, offset + 20, depth)?;
14489            self.6.encode(encoder, offset + 24, depth)?;
14490            self.7.encode(encoder, offset + 28, depth)?;
14491            self.8.encode(encoder, offset + 32, depth)?;
14492            Ok(())
14493        }
14494    }
14495
14496    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoStreamType {
14497        #[inline(always)]
14498        fn new_empty() -> Self {
14499            Self {
14500                pixel_format: fidl::new_empty!(fidl_fuchsia_images__common::PixelFormat, D),
14501                color_space: fidl::new_empty!(ColorSpace, D),
14502                width: fidl::new_empty!(u32, D),
14503                height: fidl::new_empty!(u32, D),
14504                coded_width: fidl::new_empty!(u32, D),
14505                coded_height: fidl::new_empty!(u32, D),
14506                pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14507                pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14508                stride: fidl::new_empty!(u32, D),
14509            }
14510        }
14511
14512        #[inline]
14513        unsafe fn decode(
14514            &mut self,
14515            decoder: &mut fidl::encoding::Decoder<'_, D>,
14516            offset: usize,
14517            _depth: fidl::encoding::Depth,
14518        ) -> fidl::Result<()> {
14519            decoder.debug_check_bounds::<Self>(offset);
14520            // Verify that padding bytes are zero.
14521            fidl::decode!(
14522                fidl_fuchsia_images__common::PixelFormat,
14523                D,
14524                &mut self.pixel_format,
14525                decoder,
14526                offset + 0,
14527                _depth
14528            )?;
14529            fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 4, _depth)?;
14530            fidl::decode!(u32, D, &mut self.width, decoder, offset + 8, _depth)?;
14531            fidl::decode!(u32, D, &mut self.height, decoder, offset + 12, _depth)?;
14532            fidl::decode!(u32, D, &mut self.coded_width, decoder, offset + 16, _depth)?;
14533            fidl::decode!(u32, D, &mut self.coded_height, decoder, offset + 20, _depth)?;
14534            fidl::decode!(
14535                u32,
14536                D,
14537                &mut self.pixel_aspect_ratio_width,
14538                decoder,
14539                offset + 24,
14540                _depth
14541            )?;
14542            fidl::decode!(
14543                u32,
14544                D,
14545                &mut self.pixel_aspect_ratio_height,
14546                decoder,
14547                offset + 28,
14548                _depth
14549            )?;
14550            fidl::decode!(u32, D, &mut self.stride, decoder, offset + 32, _depth)?;
14551            Ok(())
14552        }
14553    }
14554
14555    impl fidl::encoding::ValueTypeMarker for VideoUncompressedFormat {
14556        type Borrowed<'a> = &'a Self;
14557        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14558            value
14559        }
14560    }
14561
14562    unsafe impl fidl::encoding::TypeMarker for VideoUncompressedFormat {
14563        type Owned = Self;
14564
14565        #[inline(always)]
14566        fn inline_align(_context: fidl::encoding::Context) -> usize {
14567            8
14568        }
14569
14570        #[inline(always)]
14571        fn inline_size(_context: fidl::encoding::Context) -> usize {
14572            128
14573        }
14574    }
14575
14576    unsafe impl<D: fidl::encoding::ResourceDialect>
14577        fidl::encoding::Encode<VideoUncompressedFormat, D> for &VideoUncompressedFormat
14578    {
14579        #[inline]
14580        unsafe fn encode(
14581            self,
14582            encoder: &mut fidl::encoding::Encoder<'_, D>,
14583            offset: usize,
14584            _depth: fidl::encoding::Depth,
14585        ) -> fidl::Result<()> {
14586            encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14587            // Delegate to tuple encoding.
14588            fidl::encoding::Encode::<VideoUncompressedFormat, D>::encode(
14589                (
14590                    <fidl_fuchsia_sysmem__common::ImageFormat2 as fidl::encoding::ValueTypeMarker>::borrow(&self.image_format),
14591                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.fourcc),
14592                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_width_pixels),
14593                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_height_pixels),
14594                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_width_pixels),
14595                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_height_pixels),
14596                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.planar),
14597                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.swizzled),
14598                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_line_stride_bytes),
14599                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_line_stride_bytes),
14600                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_start_offset),
14601                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_start_offset),
14602                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.tertiary_start_offset),
14603                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_pixel_stride),
14604                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary_pixel_stride),
14605                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_width_pixels),
14606                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_display_height_pixels),
14607                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_pixel_aspect_ratio),
14608                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_width),
14609                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_aspect_ratio_height),
14610                ),
14611                encoder, offset, _depth
14612            )
14613        }
14614    }
14615    unsafe impl<
14616            D: fidl::encoding::ResourceDialect,
14617            T0: fidl::encoding::Encode<fidl_fuchsia_sysmem__common::ImageFormat2, D>,
14618            T1: fidl::encoding::Encode<u32, D>,
14619            T2: fidl::encoding::Encode<u32, D>,
14620            T3: fidl::encoding::Encode<u32, D>,
14621            T4: fidl::encoding::Encode<u32, D>,
14622            T5: fidl::encoding::Encode<u32, D>,
14623            T6: fidl::encoding::Encode<bool, D>,
14624            T7: fidl::encoding::Encode<bool, D>,
14625            T8: fidl::encoding::Encode<u32, D>,
14626            T9: fidl::encoding::Encode<u32, D>,
14627            T10: fidl::encoding::Encode<u32, D>,
14628            T11: fidl::encoding::Encode<u32, D>,
14629            T12: fidl::encoding::Encode<u32, D>,
14630            T13: fidl::encoding::Encode<u32, D>,
14631            T14: fidl::encoding::Encode<u32, D>,
14632            T15: fidl::encoding::Encode<u32, D>,
14633            T16: fidl::encoding::Encode<u32, D>,
14634            T17: fidl::encoding::Encode<bool, D>,
14635            T18: fidl::encoding::Encode<u32, D>,
14636            T19: fidl::encoding::Encode<u32, D>,
14637        > fidl::encoding::Encode<VideoUncompressedFormat, D>
14638        for (
14639            T0,
14640            T1,
14641            T2,
14642            T3,
14643            T4,
14644            T5,
14645            T6,
14646            T7,
14647            T8,
14648            T9,
14649            T10,
14650            T11,
14651            T12,
14652            T13,
14653            T14,
14654            T15,
14655            T16,
14656            T17,
14657            T18,
14658            T19,
14659        )
14660    {
14661        #[inline]
14662        unsafe fn encode(
14663            self,
14664            encoder: &mut fidl::encoding::Encoder<'_, D>,
14665            offset: usize,
14666            depth: fidl::encoding::Depth,
14667        ) -> fidl::Result<()> {
14668            encoder.debug_check_bounds::<VideoUncompressedFormat>(offset);
14669            // Zero out padding regions. There's no need to apply masks
14670            // because the unmasked parts will be overwritten by fields.
14671            unsafe {
14672                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
14673                (ptr as *mut u64).write_unaligned(0);
14674            }
14675            unsafe {
14676                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
14677                (ptr as *mut u64).write_unaligned(0);
14678            }
14679            // Write the fields.
14680            self.0.encode(encoder, offset + 0, depth)?;
14681            self.1.encode(encoder, offset + 56, depth)?;
14682            self.2.encode(encoder, offset + 60, depth)?;
14683            self.3.encode(encoder, offset + 64, depth)?;
14684            self.4.encode(encoder, offset + 68, depth)?;
14685            self.5.encode(encoder, offset + 72, depth)?;
14686            self.6.encode(encoder, offset + 76, depth)?;
14687            self.7.encode(encoder, offset + 77, depth)?;
14688            self.8.encode(encoder, offset + 80, depth)?;
14689            self.9.encode(encoder, offset + 84, depth)?;
14690            self.10.encode(encoder, offset + 88, depth)?;
14691            self.11.encode(encoder, offset + 92, depth)?;
14692            self.12.encode(encoder, offset + 96, depth)?;
14693            self.13.encode(encoder, offset + 100, depth)?;
14694            self.14.encode(encoder, offset + 104, depth)?;
14695            self.15.encode(encoder, offset + 108, depth)?;
14696            self.16.encode(encoder, offset + 112, depth)?;
14697            self.17.encode(encoder, offset + 116, depth)?;
14698            self.18.encode(encoder, offset + 120, depth)?;
14699            self.19.encode(encoder, offset + 124, depth)?;
14700            Ok(())
14701        }
14702    }
14703
14704    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14705        for VideoUncompressedFormat
14706    {
14707        #[inline(always)]
14708        fn new_empty() -> Self {
14709            Self {
14710                image_format: fidl::new_empty!(fidl_fuchsia_sysmem__common::ImageFormat2, D),
14711                fourcc: fidl::new_empty!(u32, D),
14712                primary_width_pixels: fidl::new_empty!(u32, D),
14713                primary_height_pixels: fidl::new_empty!(u32, D),
14714                secondary_width_pixels: fidl::new_empty!(u32, D),
14715                secondary_height_pixels: fidl::new_empty!(u32, D),
14716                planar: fidl::new_empty!(bool, D),
14717                swizzled: fidl::new_empty!(bool, D),
14718                primary_line_stride_bytes: fidl::new_empty!(u32, D),
14719                secondary_line_stride_bytes: fidl::new_empty!(u32, D),
14720                primary_start_offset: fidl::new_empty!(u32, D),
14721                secondary_start_offset: fidl::new_empty!(u32, D),
14722                tertiary_start_offset: fidl::new_empty!(u32, D),
14723                primary_pixel_stride: fidl::new_empty!(u32, D),
14724                secondary_pixel_stride: fidl::new_empty!(u32, D),
14725                primary_display_width_pixels: fidl::new_empty!(u32, D),
14726                primary_display_height_pixels: fidl::new_empty!(u32, D),
14727                has_pixel_aspect_ratio: fidl::new_empty!(bool, D),
14728                pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
14729                pixel_aspect_ratio_height: fidl::new_empty!(u32, D),
14730            }
14731        }
14732
14733        #[inline]
14734        unsafe fn decode(
14735            &mut self,
14736            decoder: &mut fidl::encoding::Decoder<'_, D>,
14737            offset: usize,
14738            _depth: fidl::encoding::Depth,
14739        ) -> fidl::Result<()> {
14740            decoder.debug_check_bounds::<Self>(offset);
14741            // Verify that padding bytes are zero.
14742            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
14743            let padval = unsafe { (ptr as *const u64).read_unaligned() };
14744            let mask = 0xffff000000000000u64;
14745            let maskedval = padval & mask;
14746            if maskedval != 0 {
14747                return Err(fidl::Error::NonZeroPadding {
14748                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
14749                });
14750            }
14751            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
14752            let padval = unsafe { (ptr as *const u64).read_unaligned() };
14753            let mask = 0xffffff0000000000u64;
14754            let maskedval = padval & mask;
14755            if maskedval != 0 {
14756                return Err(fidl::Error::NonZeroPadding {
14757                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
14758                });
14759            }
14760            fidl::decode!(
14761                fidl_fuchsia_sysmem__common::ImageFormat2,
14762                D,
14763                &mut self.image_format,
14764                decoder,
14765                offset + 0,
14766                _depth
14767            )?;
14768            fidl::decode!(u32, D, &mut self.fourcc, decoder, offset + 56, _depth)?;
14769            fidl::decode!(u32, D, &mut self.primary_width_pixels, decoder, offset + 60, _depth)?;
14770            fidl::decode!(u32, D, &mut self.primary_height_pixels, decoder, offset + 64, _depth)?;
14771            fidl::decode!(u32, D, &mut self.secondary_width_pixels, decoder, offset + 68, _depth)?;
14772            fidl::decode!(u32, D, &mut self.secondary_height_pixels, decoder, offset + 72, _depth)?;
14773            fidl::decode!(bool, D, &mut self.planar, decoder, offset + 76, _depth)?;
14774            fidl::decode!(bool, D, &mut self.swizzled, decoder, offset + 77, _depth)?;
14775            fidl::decode!(
14776                u32,
14777                D,
14778                &mut self.primary_line_stride_bytes,
14779                decoder,
14780                offset + 80,
14781                _depth
14782            )?;
14783            fidl::decode!(
14784                u32,
14785                D,
14786                &mut self.secondary_line_stride_bytes,
14787                decoder,
14788                offset + 84,
14789                _depth
14790            )?;
14791            fidl::decode!(u32, D, &mut self.primary_start_offset, decoder, offset + 88, _depth)?;
14792            fidl::decode!(u32, D, &mut self.secondary_start_offset, decoder, offset + 92, _depth)?;
14793            fidl::decode!(u32, D, &mut self.tertiary_start_offset, decoder, offset + 96, _depth)?;
14794            fidl::decode!(u32, D, &mut self.primary_pixel_stride, decoder, offset + 100, _depth)?;
14795            fidl::decode!(u32, D, &mut self.secondary_pixel_stride, decoder, offset + 104, _depth)?;
14796            fidl::decode!(
14797                u32,
14798                D,
14799                &mut self.primary_display_width_pixels,
14800                decoder,
14801                offset + 108,
14802                _depth
14803            )?;
14804            fidl::decode!(
14805                u32,
14806                D,
14807                &mut self.primary_display_height_pixels,
14808                decoder,
14809                offset + 112,
14810                _depth
14811            )?;
14812            fidl::decode!(
14813                bool,
14814                D,
14815                &mut self.has_pixel_aspect_ratio,
14816                decoder,
14817                offset + 116,
14818                _depth
14819            )?;
14820            fidl::decode!(
14821                u32,
14822                D,
14823                &mut self.pixel_aspect_ratio_width,
14824                decoder,
14825                offset + 120,
14826                _depth
14827            )?;
14828            fidl::decode!(
14829                u32,
14830                D,
14831                &mut self.pixel_aspect_ratio_height,
14832                decoder,
14833                offset + 124,
14834                _depth
14835            )?;
14836            Ok(())
14837        }
14838    }
14839
14840    impl fidl::encoding::ValueTypeMarker for Void {
14841        type Borrowed<'a> = &'a Self;
14842        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14843            value
14844        }
14845    }
14846
14847    unsafe impl fidl::encoding::TypeMarker for Void {
14848        type Owned = Self;
14849
14850        #[inline(always)]
14851        fn inline_align(_context: fidl::encoding::Context) -> usize {
14852            1
14853        }
14854
14855        #[inline(always)]
14856        fn inline_size(_context: fidl::encoding::Context) -> usize {
14857            1
14858        }
14859    }
14860
14861    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
14862        #[inline]
14863        unsafe fn encode(
14864            self,
14865            encoder: &mut fidl::encoding::Encoder<'_, D>,
14866            offset: usize,
14867            _depth: fidl::encoding::Depth,
14868        ) -> fidl::Result<()> {
14869            encoder.debug_check_bounds::<Void>(offset);
14870            encoder.write_num(0u8, offset);
14871            Ok(())
14872        }
14873    }
14874
14875    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
14876        #[inline(always)]
14877        fn new_empty() -> Self {
14878            Self
14879        }
14880
14881        #[inline]
14882        unsafe fn decode(
14883            &mut self,
14884            decoder: &mut fidl::encoding::Decoder<'_, D>,
14885            offset: usize,
14886            _depth: fidl::encoding::Depth,
14887        ) -> fidl::Result<()> {
14888            decoder.debug_check_bounds::<Self>(offset);
14889            match decoder.read_num::<u8>(offset) {
14890                0 => Ok(()),
14891                _ => Err(fidl::Error::Invalid),
14892            }
14893        }
14894    }
14895
14896    impl AudioCompressedFormatCvsd {
14897        #[inline(always)]
14898        fn max_ordinal_present(&self) -> u64 {
14899            0
14900        }
14901    }
14902
14903    impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatCvsd {
14904        type Borrowed<'a> = &'a Self;
14905        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14906            value
14907        }
14908    }
14909
14910    unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatCvsd {
14911        type Owned = Self;
14912
14913        #[inline(always)]
14914        fn inline_align(_context: fidl::encoding::Context) -> usize {
14915            8
14916        }
14917
14918        #[inline(always)]
14919        fn inline_size(_context: fidl::encoding::Context) -> usize {
14920            16
14921        }
14922    }
14923
14924    unsafe impl<D: fidl::encoding::ResourceDialect>
14925        fidl::encoding::Encode<AudioCompressedFormatCvsd, D> for &AudioCompressedFormatCvsd
14926    {
14927        unsafe fn encode(
14928            self,
14929            encoder: &mut fidl::encoding::Encoder<'_, D>,
14930            offset: usize,
14931            mut depth: fidl::encoding::Depth,
14932        ) -> fidl::Result<()> {
14933            encoder.debug_check_bounds::<AudioCompressedFormatCvsd>(offset);
14934            // Vector header
14935            let max_ordinal: u64 = self.max_ordinal_present();
14936            encoder.write_num(max_ordinal, offset);
14937            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14938            // Calling encoder.out_of_line_offset(0) is not allowed.
14939            if max_ordinal == 0 {
14940                return Ok(());
14941            }
14942            depth.increment()?;
14943            let envelope_size = 8;
14944            let bytes_len = max_ordinal as usize * envelope_size;
14945            #[allow(unused_variables)]
14946            let offset = encoder.out_of_line_offset(bytes_len);
14947            let mut _prev_end_offset: usize = 0;
14948
14949            Ok(())
14950        }
14951    }
14952
14953    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
14954        for AudioCompressedFormatCvsd
14955    {
14956        #[inline(always)]
14957        fn new_empty() -> Self {
14958            Self::default()
14959        }
14960
14961        unsafe fn decode(
14962            &mut self,
14963            decoder: &mut fidl::encoding::Decoder<'_, D>,
14964            offset: usize,
14965            mut depth: fidl::encoding::Depth,
14966        ) -> fidl::Result<()> {
14967            decoder.debug_check_bounds::<Self>(offset);
14968            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14969                None => return Err(fidl::Error::NotNullable),
14970                Some(len) => len,
14971            };
14972            // Calling decoder.out_of_line_offset(0) is not allowed.
14973            if len == 0 {
14974                return Ok(());
14975            };
14976            depth.increment()?;
14977            let envelope_size = 8;
14978            let bytes_len = len * envelope_size;
14979            let offset = decoder.out_of_line_offset(bytes_len)?;
14980            // Decode the envelope for each type.
14981            let mut _next_ordinal_to_read = 0;
14982            let mut next_offset = offset;
14983            let end_offset = offset + bytes_len;
14984
14985            // Decode the remaining unknown envelopes.
14986            while next_offset < end_offset {
14987                _next_ordinal_to_read += 1;
14988                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14989                next_offset += envelope_size;
14990            }
14991
14992            Ok(())
14993        }
14994    }
14995
14996    impl AudioCompressedFormatLc3 {
14997        #[inline(always)]
14998        fn max_ordinal_present(&self) -> u64 {
14999            0
15000        }
15001    }
15002
15003    impl fidl::encoding::ValueTypeMarker for AudioCompressedFormatLc3 {
15004        type Borrowed<'a> = &'a Self;
15005        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15006            value
15007        }
15008    }
15009
15010    unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormatLc3 {
15011        type Owned = Self;
15012
15013        #[inline(always)]
15014        fn inline_align(_context: fidl::encoding::Context) -> usize {
15015            8
15016        }
15017
15018        #[inline(always)]
15019        fn inline_size(_context: fidl::encoding::Context) -> usize {
15020            16
15021        }
15022    }
15023
15024    unsafe impl<D: fidl::encoding::ResourceDialect>
15025        fidl::encoding::Encode<AudioCompressedFormatLc3, D> for &AudioCompressedFormatLc3
15026    {
15027        unsafe fn encode(
15028            self,
15029            encoder: &mut fidl::encoding::Encoder<'_, D>,
15030            offset: usize,
15031            mut depth: fidl::encoding::Depth,
15032        ) -> fidl::Result<()> {
15033            encoder.debug_check_bounds::<AudioCompressedFormatLc3>(offset);
15034            // Vector header
15035            let max_ordinal: u64 = self.max_ordinal_present();
15036            encoder.write_num(max_ordinal, offset);
15037            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15038            // Calling encoder.out_of_line_offset(0) is not allowed.
15039            if max_ordinal == 0 {
15040                return Ok(());
15041            }
15042            depth.increment()?;
15043            let envelope_size = 8;
15044            let bytes_len = max_ordinal as usize * envelope_size;
15045            #[allow(unused_variables)]
15046            let offset = encoder.out_of_line_offset(bytes_len);
15047            let mut _prev_end_offset: usize = 0;
15048
15049            Ok(())
15050        }
15051    }
15052
15053    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
15054        for AudioCompressedFormatLc3
15055    {
15056        #[inline(always)]
15057        fn new_empty() -> Self {
15058            Self::default()
15059        }
15060
15061        unsafe fn decode(
15062            &mut self,
15063            decoder: &mut fidl::encoding::Decoder<'_, D>,
15064            offset: usize,
15065            mut depth: fidl::encoding::Depth,
15066        ) -> fidl::Result<()> {
15067            decoder.debug_check_bounds::<Self>(offset);
15068            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15069                None => return Err(fidl::Error::NotNullable),
15070                Some(len) => len,
15071            };
15072            // Calling decoder.out_of_line_offset(0) is not allowed.
15073            if len == 0 {
15074                return Ok(());
15075            };
15076            depth.increment()?;
15077            let envelope_size = 8;
15078            let bytes_len = len * envelope_size;
15079            let offset = decoder.out_of_line_offset(bytes_len)?;
15080            // Decode the envelope for each type.
15081            let mut _next_ordinal_to_read = 0;
15082            let mut next_offset = offset;
15083            let end_offset = offset + bytes_len;
15084
15085            // Decode the remaining unknown envelopes.
15086            while next_offset < end_offset {
15087                _next_ordinal_to_read += 1;
15088                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15089                next_offset += envelope_size;
15090            }
15091
15092            Ok(())
15093        }
15094    }
15095
15096    impl AudioConsumerStatus {
15097        #[inline(always)]
15098        fn max_ordinal_present(&self) -> u64 {
15099            if let Some(_) = self.max_lead_time {
15100                return 4;
15101            }
15102            if let Some(_) = self.min_lead_time {
15103                return 3;
15104            }
15105            if let Some(_) = self.presentation_timeline {
15106                return 2;
15107            }
15108            if let Some(_) = self.error {
15109                return 1;
15110            }
15111            0
15112        }
15113    }
15114
15115    impl fidl::encoding::ValueTypeMarker for AudioConsumerStatus {
15116        type Borrowed<'a> = &'a Self;
15117        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15118            value
15119        }
15120    }
15121
15122    unsafe impl fidl::encoding::TypeMarker for AudioConsumerStatus {
15123        type Owned = Self;
15124
15125        #[inline(always)]
15126        fn inline_align(_context: fidl::encoding::Context) -> usize {
15127            8
15128        }
15129
15130        #[inline(always)]
15131        fn inline_size(_context: fidl::encoding::Context) -> usize {
15132            16
15133        }
15134    }
15135
15136    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerStatus, D>
15137        for &AudioConsumerStatus
15138    {
15139        unsafe fn encode(
15140            self,
15141            encoder: &mut fidl::encoding::Encoder<'_, D>,
15142            offset: usize,
15143            mut depth: fidl::encoding::Depth,
15144        ) -> fidl::Result<()> {
15145            encoder.debug_check_bounds::<AudioConsumerStatus>(offset);
15146            // Vector header
15147            let max_ordinal: u64 = self.max_ordinal_present();
15148            encoder.write_num(max_ordinal, offset);
15149            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15150            // Calling encoder.out_of_line_offset(0) is not allowed.
15151            if max_ordinal == 0 {
15152                return Ok(());
15153            }
15154            depth.increment()?;
15155            let envelope_size = 8;
15156            let bytes_len = max_ordinal as usize * envelope_size;
15157            #[allow(unused_variables)]
15158            let offset = encoder.out_of_line_offset(bytes_len);
15159            let mut _prev_end_offset: usize = 0;
15160            if 1 > max_ordinal {
15161                return Ok(());
15162            }
15163
15164            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15165            // are envelope_size bytes.
15166            let cur_offset: usize = (1 - 1) * envelope_size;
15167
15168            // Zero reserved fields.
15169            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15170
15171            // Safety:
15172            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15173            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15174            //   envelope_size bytes, there is always sufficient room.
15175            fidl::encoding::encode_in_envelope_optional::<AudioConsumerError, D>(
15176                self.error
15177                    .as_ref()
15178                    .map(<AudioConsumerError as fidl::encoding::ValueTypeMarker>::borrow),
15179                encoder,
15180                offset + cur_offset,
15181                depth,
15182            )?;
15183
15184            _prev_end_offset = cur_offset + envelope_size;
15185            if 2 > max_ordinal {
15186                return Ok(());
15187            }
15188
15189            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15190            // are envelope_size bytes.
15191            let cur_offset: usize = (2 - 1) * envelope_size;
15192
15193            // Zero reserved fields.
15194            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15195
15196            // Safety:
15197            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15198            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15199            //   envelope_size bytes, there is always sufficient room.
15200            fidl::encoding::encode_in_envelope_optional::<TimelineFunction, D>(
15201                self.presentation_timeline
15202                    .as_ref()
15203                    .map(<TimelineFunction as fidl::encoding::ValueTypeMarker>::borrow),
15204                encoder,
15205                offset + cur_offset,
15206                depth,
15207            )?;
15208
15209            _prev_end_offset = cur_offset + envelope_size;
15210            if 3 > max_ordinal {
15211                return Ok(());
15212            }
15213
15214            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15215            // are envelope_size bytes.
15216            let cur_offset: usize = (3 - 1) * envelope_size;
15217
15218            // Zero reserved fields.
15219            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15220
15221            // Safety:
15222            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15223            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15224            //   envelope_size bytes, there is always sufficient room.
15225            fidl::encoding::encode_in_envelope_optional::<u64, D>(
15226                self.min_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15227                encoder,
15228                offset + cur_offset,
15229                depth,
15230            )?;
15231
15232            _prev_end_offset = cur_offset + envelope_size;
15233            if 4 > max_ordinal {
15234                return Ok(());
15235            }
15236
15237            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15238            // are envelope_size bytes.
15239            let cur_offset: usize = (4 - 1) * envelope_size;
15240
15241            // Zero reserved fields.
15242            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15243
15244            // Safety:
15245            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15246            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15247            //   envelope_size bytes, there is always sufficient room.
15248            fidl::encoding::encode_in_envelope_optional::<u64, D>(
15249                self.max_lead_time.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15250                encoder,
15251                offset + cur_offset,
15252                depth,
15253            )?;
15254
15255            _prev_end_offset = cur_offset + envelope_size;
15256
15257            Ok(())
15258        }
15259    }
15260
15261    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerStatus {
15262        #[inline(always)]
15263        fn new_empty() -> Self {
15264            Self::default()
15265        }
15266
15267        unsafe fn decode(
15268            &mut self,
15269            decoder: &mut fidl::encoding::Decoder<'_, D>,
15270            offset: usize,
15271            mut depth: fidl::encoding::Depth,
15272        ) -> fidl::Result<()> {
15273            decoder.debug_check_bounds::<Self>(offset);
15274            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15275                None => return Err(fidl::Error::NotNullable),
15276                Some(len) => len,
15277            };
15278            // Calling decoder.out_of_line_offset(0) is not allowed.
15279            if len == 0 {
15280                return Ok(());
15281            };
15282            depth.increment()?;
15283            let envelope_size = 8;
15284            let bytes_len = len * envelope_size;
15285            let offset = decoder.out_of_line_offset(bytes_len)?;
15286            // Decode the envelope for each type.
15287            let mut _next_ordinal_to_read = 0;
15288            let mut next_offset = offset;
15289            let end_offset = offset + bytes_len;
15290            _next_ordinal_to_read += 1;
15291            if next_offset >= end_offset {
15292                return Ok(());
15293            }
15294
15295            // Decode unknown envelopes for gaps in ordinals.
15296            while _next_ordinal_to_read < 1 {
15297                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15298                _next_ordinal_to_read += 1;
15299                next_offset += envelope_size;
15300            }
15301
15302            let next_out_of_line = decoder.next_out_of_line();
15303            let handles_before = decoder.remaining_handles();
15304            if let Some((inlined, num_bytes, num_handles)) =
15305                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15306            {
15307                let member_inline_size =
15308                    <AudioConsumerError as fidl::encoding::TypeMarker>::inline_size(
15309                        decoder.context,
15310                    );
15311                if inlined != (member_inline_size <= 4) {
15312                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15313                }
15314                let inner_offset;
15315                let mut inner_depth = depth.clone();
15316                if inlined {
15317                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15318                    inner_offset = next_offset;
15319                } else {
15320                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15321                    inner_depth.increment()?;
15322                }
15323                let val_ref =
15324                    self.error.get_or_insert_with(|| fidl::new_empty!(AudioConsumerError, D));
15325                fidl::decode!(AudioConsumerError, D, val_ref, decoder, inner_offset, inner_depth)?;
15326                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15327                {
15328                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15329                }
15330                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15331                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15332                }
15333            }
15334
15335            next_offset += envelope_size;
15336            _next_ordinal_to_read += 1;
15337            if next_offset >= end_offset {
15338                return Ok(());
15339            }
15340
15341            // Decode unknown envelopes for gaps in ordinals.
15342            while _next_ordinal_to_read < 2 {
15343                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15344                _next_ordinal_to_read += 1;
15345                next_offset += envelope_size;
15346            }
15347
15348            let next_out_of_line = decoder.next_out_of_line();
15349            let handles_before = decoder.remaining_handles();
15350            if let Some((inlined, num_bytes, num_handles)) =
15351                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15352            {
15353                let member_inline_size =
15354                    <TimelineFunction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15355                if inlined != (member_inline_size <= 4) {
15356                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15357                }
15358                let inner_offset;
15359                let mut inner_depth = depth.clone();
15360                if inlined {
15361                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15362                    inner_offset = next_offset;
15363                } else {
15364                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15365                    inner_depth.increment()?;
15366                }
15367                let val_ref = self
15368                    .presentation_timeline
15369                    .get_or_insert_with(|| fidl::new_empty!(TimelineFunction, D));
15370                fidl::decode!(TimelineFunction, D, val_ref, decoder, inner_offset, inner_depth)?;
15371                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15372                {
15373                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15374                }
15375                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15376                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15377                }
15378            }
15379
15380            next_offset += envelope_size;
15381            _next_ordinal_to_read += 1;
15382            if next_offset >= end_offset {
15383                return Ok(());
15384            }
15385
15386            // Decode unknown envelopes for gaps in ordinals.
15387            while _next_ordinal_to_read < 3 {
15388                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15389                _next_ordinal_to_read += 1;
15390                next_offset += envelope_size;
15391            }
15392
15393            let next_out_of_line = decoder.next_out_of_line();
15394            let handles_before = decoder.remaining_handles();
15395            if let Some((inlined, num_bytes, num_handles)) =
15396                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15397            {
15398                let member_inline_size =
15399                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15400                if inlined != (member_inline_size <= 4) {
15401                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15402                }
15403                let inner_offset;
15404                let mut inner_depth = depth.clone();
15405                if inlined {
15406                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15407                    inner_offset = next_offset;
15408                } else {
15409                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15410                    inner_depth.increment()?;
15411                }
15412                let val_ref = self.min_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15413                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15414                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15415                {
15416                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15417                }
15418                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15419                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15420                }
15421            }
15422
15423            next_offset += envelope_size;
15424            _next_ordinal_to_read += 1;
15425            if next_offset >= end_offset {
15426                return Ok(());
15427            }
15428
15429            // Decode unknown envelopes for gaps in ordinals.
15430            while _next_ordinal_to_read < 4 {
15431                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15432                _next_ordinal_to_read += 1;
15433                next_offset += envelope_size;
15434            }
15435
15436            let next_out_of_line = decoder.next_out_of_line();
15437            let handles_before = decoder.remaining_handles();
15438            if let Some((inlined, num_bytes, num_handles)) =
15439                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15440            {
15441                let member_inline_size =
15442                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15443                if inlined != (member_inline_size <= 4) {
15444                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15445                }
15446                let inner_offset;
15447                let mut inner_depth = depth.clone();
15448                if inlined {
15449                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15450                    inner_offset = next_offset;
15451                } else {
15452                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15453                    inner_depth.increment()?;
15454                }
15455                let val_ref = self.max_lead_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
15456                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15458                {
15459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15460                }
15461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15463                }
15464            }
15465
15466            next_offset += envelope_size;
15467
15468            // Decode the remaining unknown envelopes.
15469            while next_offset < end_offset {
15470                _next_ordinal_to_read += 1;
15471                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15472                next_offset += envelope_size;
15473            }
15474
15475            Ok(())
15476        }
15477    }
15478
15479    impl CvsdEncoderSettings {
15480        #[inline(always)]
15481        fn max_ordinal_present(&self) -> u64 {
15482            0
15483        }
15484    }
15485
15486    impl fidl::encoding::ValueTypeMarker for CvsdEncoderSettings {
15487        type Borrowed<'a> = &'a Self;
15488        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15489            value
15490        }
15491    }
15492
15493    unsafe impl fidl::encoding::TypeMarker for CvsdEncoderSettings {
15494        type Owned = Self;
15495
15496        #[inline(always)]
15497        fn inline_align(_context: fidl::encoding::Context) -> usize {
15498            8
15499        }
15500
15501        #[inline(always)]
15502        fn inline_size(_context: fidl::encoding::Context) -> usize {
15503            16
15504        }
15505    }
15506
15507    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CvsdEncoderSettings, D>
15508        for &CvsdEncoderSettings
15509    {
15510        unsafe fn encode(
15511            self,
15512            encoder: &mut fidl::encoding::Encoder<'_, D>,
15513            offset: usize,
15514            mut depth: fidl::encoding::Depth,
15515        ) -> fidl::Result<()> {
15516            encoder.debug_check_bounds::<CvsdEncoderSettings>(offset);
15517            // Vector header
15518            let max_ordinal: u64 = self.max_ordinal_present();
15519            encoder.write_num(max_ordinal, offset);
15520            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15521            // Calling encoder.out_of_line_offset(0) is not allowed.
15522            if max_ordinal == 0 {
15523                return Ok(());
15524            }
15525            depth.increment()?;
15526            let envelope_size = 8;
15527            let bytes_len = max_ordinal as usize * envelope_size;
15528            #[allow(unused_variables)]
15529            let offset = encoder.out_of_line_offset(bytes_len);
15530            let mut _prev_end_offset: usize = 0;
15531
15532            Ok(())
15533        }
15534    }
15535
15536    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CvsdEncoderSettings {
15537        #[inline(always)]
15538        fn new_empty() -> Self {
15539            Self::default()
15540        }
15541
15542        unsafe fn decode(
15543            &mut self,
15544            decoder: &mut fidl::encoding::Decoder<'_, D>,
15545            offset: usize,
15546            mut depth: fidl::encoding::Depth,
15547        ) -> fidl::Result<()> {
15548            decoder.debug_check_bounds::<Self>(offset);
15549            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15550                None => return Err(fidl::Error::NotNullable),
15551                Some(len) => len,
15552            };
15553            // Calling decoder.out_of_line_offset(0) is not allowed.
15554            if len == 0 {
15555                return Ok(());
15556            };
15557            depth.increment()?;
15558            let envelope_size = 8;
15559            let bytes_len = len * envelope_size;
15560            let offset = decoder.out_of_line_offset(bytes_len)?;
15561            // Decode the envelope for each type.
15562            let mut _next_ordinal_to_read = 0;
15563            let mut next_offset = offset;
15564            let end_offset = offset + bytes_len;
15565
15566            // Decode the remaining unknown envelopes.
15567            while next_offset < end_offset {
15568                _next_ordinal_to_read += 1;
15569                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15570                next_offset += envelope_size;
15571            }
15572
15573            Ok(())
15574        }
15575    }
15576
15577    impl DecryptedFormat {
15578        #[inline(always)]
15579        fn max_ordinal_present(&self) -> u64 {
15580            if let Some(_) = self.ignore_this_field {
15581                return 1;
15582            }
15583            0
15584        }
15585    }
15586
15587    impl fidl::encoding::ValueTypeMarker for DecryptedFormat {
15588        type Borrowed<'a> = &'a Self;
15589        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15590            value
15591        }
15592    }
15593
15594    unsafe impl fidl::encoding::TypeMarker for DecryptedFormat {
15595        type Owned = Self;
15596
15597        #[inline(always)]
15598        fn inline_align(_context: fidl::encoding::Context) -> usize {
15599            8
15600        }
15601
15602        #[inline(always)]
15603        fn inline_size(_context: fidl::encoding::Context) -> usize {
15604            16
15605        }
15606    }
15607
15608    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DecryptedFormat, D>
15609        for &DecryptedFormat
15610    {
15611        unsafe fn encode(
15612            self,
15613            encoder: &mut fidl::encoding::Encoder<'_, D>,
15614            offset: usize,
15615            mut depth: fidl::encoding::Depth,
15616        ) -> fidl::Result<()> {
15617            encoder.debug_check_bounds::<DecryptedFormat>(offset);
15618            // Vector header
15619            let max_ordinal: u64 = self.max_ordinal_present();
15620            encoder.write_num(max_ordinal, offset);
15621            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15622            // Calling encoder.out_of_line_offset(0) is not allowed.
15623            if max_ordinal == 0 {
15624                return Ok(());
15625            }
15626            depth.increment()?;
15627            let envelope_size = 8;
15628            let bytes_len = max_ordinal as usize * envelope_size;
15629            #[allow(unused_variables)]
15630            let offset = encoder.out_of_line_offset(bytes_len);
15631            let mut _prev_end_offset: usize = 0;
15632            if 1 > max_ordinal {
15633                return Ok(());
15634            }
15635
15636            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15637            // are envelope_size bytes.
15638            let cur_offset: usize = (1 - 1) * envelope_size;
15639
15640            // Zero reserved fields.
15641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15642
15643            // Safety:
15644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15646            //   envelope_size bytes, there is always sufficient room.
15647            fidl::encoding::encode_in_envelope_optional::<bool, D>(
15648                self.ignore_this_field
15649                    .as_ref()
15650                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
15651                encoder,
15652                offset + cur_offset,
15653                depth,
15654            )?;
15655
15656            _prev_end_offset = cur_offset + envelope_size;
15657
15658            Ok(())
15659        }
15660    }
15661
15662    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DecryptedFormat {
15663        #[inline(always)]
15664        fn new_empty() -> Self {
15665            Self::default()
15666        }
15667
15668        unsafe fn decode(
15669            &mut self,
15670            decoder: &mut fidl::encoding::Decoder<'_, D>,
15671            offset: usize,
15672            mut depth: fidl::encoding::Depth,
15673        ) -> fidl::Result<()> {
15674            decoder.debug_check_bounds::<Self>(offset);
15675            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15676                None => return Err(fidl::Error::NotNullable),
15677                Some(len) => len,
15678            };
15679            // Calling decoder.out_of_line_offset(0) is not allowed.
15680            if len == 0 {
15681                return Ok(());
15682            };
15683            depth.increment()?;
15684            let envelope_size = 8;
15685            let bytes_len = len * envelope_size;
15686            let offset = decoder.out_of_line_offset(bytes_len)?;
15687            // Decode the envelope for each type.
15688            let mut _next_ordinal_to_read = 0;
15689            let mut next_offset = offset;
15690            let end_offset = offset + bytes_len;
15691            _next_ordinal_to_read += 1;
15692            if next_offset >= end_offset {
15693                return Ok(());
15694            }
15695
15696            // Decode unknown envelopes for gaps in ordinals.
15697            while _next_ordinal_to_read < 1 {
15698                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15699                _next_ordinal_to_read += 1;
15700                next_offset += envelope_size;
15701            }
15702
15703            let next_out_of_line = decoder.next_out_of_line();
15704            let handles_before = decoder.remaining_handles();
15705            if let Some((inlined, num_bytes, num_handles)) =
15706                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15707            {
15708                let member_inline_size =
15709                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15710                if inlined != (member_inline_size <= 4) {
15711                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15712                }
15713                let inner_offset;
15714                let mut inner_depth = depth.clone();
15715                if inlined {
15716                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15717                    inner_offset = next_offset;
15718                } else {
15719                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15720                    inner_depth.increment()?;
15721                }
15722                let val_ref =
15723                    self.ignore_this_field.get_or_insert_with(|| fidl::new_empty!(bool, D));
15724                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
15725                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15726                {
15727                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15728                }
15729                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15730                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15731                }
15732            }
15733
15734            next_offset += envelope_size;
15735
15736            // Decode the remaining unknown envelopes.
15737            while next_offset < end_offset {
15738                _next_ordinal_to_read += 1;
15739                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15740                next_offset += envelope_size;
15741            }
15742
15743            Ok(())
15744        }
15745    }
15746
15747    impl EncryptedFormat {
15748        #[inline(always)]
15749        fn max_ordinal_present(&self) -> u64 {
15750            if let Some(_) = self.key_id {
15751                return 8;
15752            }
15753            if let Some(_) = self.scheme {
15754                return 6;
15755            }
15756            if let Some(_) = self.pattern {
15757                return 5;
15758            }
15759            if let Some(_) = self.subsamples {
15760                return 4;
15761            }
15762            if let Some(_) = self.init_vector {
15763                return 3;
15764            }
15765            0
15766        }
15767    }
15768
15769    impl fidl::encoding::ValueTypeMarker for EncryptedFormat {
15770        type Borrowed<'a> = &'a Self;
15771        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15772            value
15773        }
15774    }
15775
15776    unsafe impl fidl::encoding::TypeMarker for EncryptedFormat {
15777        type Owned = Self;
15778
15779        #[inline(always)]
15780        fn inline_align(_context: fidl::encoding::Context) -> usize {
15781            8
15782        }
15783
15784        #[inline(always)]
15785        fn inline_size(_context: fidl::encoding::Context) -> usize {
15786            16
15787        }
15788    }
15789
15790    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncryptedFormat, D>
15791        for &EncryptedFormat
15792    {
15793        unsafe fn encode(
15794            self,
15795            encoder: &mut fidl::encoding::Encoder<'_, D>,
15796            offset: usize,
15797            mut depth: fidl::encoding::Depth,
15798        ) -> fidl::Result<()> {
15799            encoder.debug_check_bounds::<EncryptedFormat>(offset);
15800            // Vector header
15801            let max_ordinal: u64 = self.max_ordinal_present();
15802            encoder.write_num(max_ordinal, offset);
15803            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15804            // Calling encoder.out_of_line_offset(0) is not allowed.
15805            if max_ordinal == 0 {
15806                return Ok(());
15807            }
15808            depth.increment()?;
15809            let envelope_size = 8;
15810            let bytes_len = max_ordinal as usize * envelope_size;
15811            #[allow(unused_variables)]
15812            let offset = encoder.out_of_line_offset(bytes_len);
15813            let mut _prev_end_offset: usize = 0;
15814            if 3 > max_ordinal {
15815                return Ok(());
15816            }
15817
15818            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15819            // are envelope_size bytes.
15820            let cur_offset: usize = (3 - 1) * envelope_size;
15821
15822            // Zero reserved fields.
15823            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15824
15825            // Safety:
15826            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15827            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15828            //   envelope_size bytes, there is always sufficient room.
15829            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15830                self.init_vector.as_ref().map(
15831                    <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15832                ),
15833                encoder,
15834                offset + cur_offset,
15835                depth,
15836            )?;
15837
15838            _prev_end_offset = cur_offset + envelope_size;
15839            if 4 > max_ordinal {
15840                return Ok(());
15841            }
15842
15843            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15844            // are envelope_size bytes.
15845            let cur_offset: usize = (4 - 1) * envelope_size;
15846
15847            // Zero reserved fields.
15848            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15849
15850            // Safety:
15851            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15852            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15853            //   envelope_size bytes, there is always sufficient room.
15854            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<SubsampleEntry>, D>(
15855            self.subsamples.as_ref().map(<fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::ValueTypeMarker>::borrow),
15856            encoder, offset + cur_offset, depth
15857        )?;
15858
15859            _prev_end_offset = cur_offset + envelope_size;
15860            if 5 > max_ordinal {
15861                return Ok(());
15862            }
15863
15864            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15865            // are envelope_size bytes.
15866            let cur_offset: usize = (5 - 1) * envelope_size;
15867
15868            // Zero reserved fields.
15869            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15870
15871            // Safety:
15872            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15873            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15874            //   envelope_size bytes, there is always sufficient room.
15875            fidl::encoding::encode_in_envelope_optional::<EncryptionPattern, D>(
15876                self.pattern
15877                    .as_ref()
15878                    .map(<EncryptionPattern as fidl::encoding::ValueTypeMarker>::borrow),
15879                encoder,
15880                offset + cur_offset,
15881                depth,
15882            )?;
15883
15884            _prev_end_offset = cur_offset + envelope_size;
15885            if 6 > max_ordinal {
15886                return Ok(());
15887            }
15888
15889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15890            // are envelope_size bytes.
15891            let cur_offset: usize = (6 - 1) * envelope_size;
15892
15893            // Zero reserved fields.
15894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15895
15896            // Safety:
15897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15899            //   envelope_size bytes, there is always sufficient room.
15900            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
15901                self.scheme.as_ref().map(
15902                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
15903                ),
15904                encoder,
15905                offset + cur_offset,
15906                depth,
15907            )?;
15908
15909            _prev_end_offset = cur_offset + envelope_size;
15910            if 8 > max_ordinal {
15911                return Ok(());
15912            }
15913
15914            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15915            // are envelope_size bytes.
15916            let cur_offset: usize = (8 - 1) * envelope_size;
15917
15918            // Zero reserved fields.
15919            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15920
15921            // Safety:
15922            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15923            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15924            //   envelope_size bytes, there is always sufficient room.
15925            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16>, D>(
15926                self.key_id.as_ref().map(
15927                    <fidl::encoding::Vector<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
15928                ),
15929                encoder,
15930                offset + cur_offset,
15931                depth,
15932            )?;
15933
15934            _prev_end_offset = cur_offset + envelope_size;
15935
15936            Ok(())
15937        }
15938    }
15939
15940    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncryptedFormat {
15941        #[inline(always)]
15942        fn new_empty() -> Self {
15943            Self::default()
15944        }
15945
15946        unsafe fn decode(
15947            &mut self,
15948            decoder: &mut fidl::encoding::Decoder<'_, D>,
15949            offset: usize,
15950            mut depth: fidl::encoding::Depth,
15951        ) -> fidl::Result<()> {
15952            decoder.debug_check_bounds::<Self>(offset);
15953            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15954                None => return Err(fidl::Error::NotNullable),
15955                Some(len) => len,
15956            };
15957            // Calling decoder.out_of_line_offset(0) is not allowed.
15958            if len == 0 {
15959                return Ok(());
15960            };
15961            depth.increment()?;
15962            let envelope_size = 8;
15963            let bytes_len = len * envelope_size;
15964            let offset = decoder.out_of_line_offset(bytes_len)?;
15965            // Decode the envelope for each type.
15966            let mut _next_ordinal_to_read = 0;
15967            let mut next_offset = offset;
15968            let end_offset = offset + bytes_len;
15969            _next_ordinal_to_read += 1;
15970            if next_offset >= end_offset {
15971                return Ok(());
15972            }
15973
15974            // Decode unknown envelopes for gaps in ordinals.
15975            while _next_ordinal_to_read < 3 {
15976                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15977                _next_ordinal_to_read += 1;
15978                next_offset += envelope_size;
15979            }
15980
15981            let next_out_of_line = decoder.next_out_of_line();
15982            let handles_before = decoder.remaining_handles();
15983            if let Some((inlined, num_bytes, num_handles)) =
15984                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15985            {
15986                let member_inline_size =
15987                    <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
15988                        decoder.context,
15989                    );
15990                if inlined != (member_inline_size <= 4) {
15991                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15992                }
15993                let inner_offset;
15994                let mut inner_depth = depth.clone();
15995                if inlined {
15996                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15997                    inner_offset = next_offset;
15998                } else {
15999                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16000                    inner_depth.increment()?;
16001                }
16002                let val_ref = self
16003                    .init_vector
16004                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
16005                fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
16006                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16007                {
16008                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16009                }
16010                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16011                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16012                }
16013            }
16014
16015            next_offset += envelope_size;
16016            _next_ordinal_to_read += 1;
16017            if next_offset >= end_offset {
16018                return Ok(());
16019            }
16020
16021            // Decode unknown envelopes for gaps in ordinals.
16022            while _next_ordinal_to_read < 4 {
16023                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16024                _next_ordinal_to_read += 1;
16025                next_offset += envelope_size;
16026            }
16027
16028            let next_out_of_line = decoder.next_out_of_line();
16029            let handles_before = decoder.remaining_handles();
16030            if let Some((inlined, num_bytes, num_handles)) =
16031                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16032            {
16033                let member_inline_size = <fidl::encoding::UnboundedVector<SubsampleEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16034                if inlined != (member_inline_size <= 4) {
16035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16036                }
16037                let inner_offset;
16038                let mut inner_depth = depth.clone();
16039                if inlined {
16040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16041                    inner_offset = next_offset;
16042                } else {
16043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16044                    inner_depth.increment()?;
16045                }
16046                let val_ref = self.subsamples.get_or_insert_with(|| {
16047                    fidl::new_empty!(fidl::encoding::UnboundedVector<SubsampleEntry>, D)
16048                });
16049                fidl::decode!(
16050                    fidl::encoding::UnboundedVector<SubsampleEntry>,
16051                    D,
16052                    val_ref,
16053                    decoder,
16054                    inner_offset,
16055                    inner_depth
16056                )?;
16057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16058                {
16059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16060                }
16061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16063                }
16064            }
16065
16066            next_offset += envelope_size;
16067            _next_ordinal_to_read += 1;
16068            if next_offset >= end_offset {
16069                return Ok(());
16070            }
16071
16072            // Decode unknown envelopes for gaps in ordinals.
16073            while _next_ordinal_to_read < 5 {
16074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16075                _next_ordinal_to_read += 1;
16076                next_offset += envelope_size;
16077            }
16078
16079            let next_out_of_line = decoder.next_out_of_line();
16080            let handles_before = decoder.remaining_handles();
16081            if let Some((inlined, num_bytes, num_handles)) =
16082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16083            {
16084                let member_inline_size =
16085                    <EncryptionPattern as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16086                if inlined != (member_inline_size <= 4) {
16087                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16088                }
16089                let inner_offset;
16090                let mut inner_depth = depth.clone();
16091                if inlined {
16092                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16093                    inner_offset = next_offset;
16094                } else {
16095                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16096                    inner_depth.increment()?;
16097                }
16098                let val_ref =
16099                    self.pattern.get_or_insert_with(|| fidl::new_empty!(EncryptionPattern, D));
16100                fidl::decode!(EncryptionPattern, D, val_ref, decoder, inner_offset, inner_depth)?;
16101                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16102                {
16103                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16104                }
16105                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16106                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16107                }
16108            }
16109
16110            next_offset += envelope_size;
16111            _next_ordinal_to_read += 1;
16112            if next_offset >= end_offset {
16113                return Ok(());
16114            }
16115
16116            // Decode unknown envelopes for gaps in ordinals.
16117            while _next_ordinal_to_read < 6 {
16118                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16119                _next_ordinal_to_read += 1;
16120                next_offset += envelope_size;
16121            }
16122
16123            let next_out_of_line = decoder.next_out_of_line();
16124            let handles_before = decoder.remaining_handles();
16125            if let Some((inlined, num_bytes, num_handles)) =
16126                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16127            {
16128                let member_inline_size =
16129                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
16130                        decoder.context,
16131                    );
16132                if inlined != (member_inline_size <= 4) {
16133                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16134                }
16135                let inner_offset;
16136                let mut inner_depth = depth.clone();
16137                if inlined {
16138                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16139                    inner_offset = next_offset;
16140                } else {
16141                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16142                    inner_depth.increment()?;
16143                }
16144                let val_ref = self
16145                    .scheme
16146                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
16147                fidl::decode!(
16148                    fidl::encoding::UnboundedString,
16149                    D,
16150                    val_ref,
16151                    decoder,
16152                    inner_offset,
16153                    inner_depth
16154                )?;
16155                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16156                {
16157                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16158                }
16159                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16160                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16161                }
16162            }
16163
16164            next_offset += envelope_size;
16165            _next_ordinal_to_read += 1;
16166            if next_offset >= end_offset {
16167                return Ok(());
16168            }
16169
16170            // Decode unknown envelopes for gaps in ordinals.
16171            while _next_ordinal_to_read < 8 {
16172                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16173                _next_ordinal_to_read += 1;
16174                next_offset += envelope_size;
16175            }
16176
16177            let next_out_of_line = decoder.next_out_of_line();
16178            let handles_before = decoder.remaining_handles();
16179            if let Some((inlined, num_bytes, num_handles)) =
16180                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16181            {
16182                let member_inline_size =
16183                    <fidl::encoding::Vector<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
16184                        decoder.context,
16185                    );
16186                if inlined != (member_inline_size <= 4) {
16187                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16188                }
16189                let inner_offset;
16190                let mut inner_depth = depth.clone();
16191                if inlined {
16192                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16193                    inner_offset = next_offset;
16194                } else {
16195                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16196                    inner_depth.increment()?;
16197                }
16198                let val_ref = self
16199                    .key_id
16200                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16>, D));
16201                fidl::decode!(fidl::encoding::Vector<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
16202                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16203                {
16204                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16205                }
16206                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16207                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16208                }
16209            }
16210
16211            next_offset += envelope_size;
16212
16213            // Decode the remaining unknown envelopes.
16214            while next_offset < end_offset {
16215                _next_ordinal_to_read += 1;
16216                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16217                next_offset += envelope_size;
16218            }
16219
16220            Ok(())
16221        }
16222    }
16223
16224    impl FormatDetails {
16225        #[inline(always)]
16226        fn max_ordinal_present(&self) -> u64 {
16227            if let Some(_) = self.profile {
16228                return 8;
16229            }
16230            if let Some(_) = self.timebase {
16231                return 7;
16232            }
16233            if let Some(_) = self.encoder_settings {
16234                return 6;
16235            }
16236            if let Some(_) = self.pass_through_parameters {
16237                return 5;
16238            }
16239            if let Some(_) = self.domain {
16240                return 4;
16241            }
16242            if let Some(_) = self.oob_bytes {
16243                return 3;
16244            }
16245            if let Some(_) = self.mime_type {
16246                return 2;
16247            }
16248            if let Some(_) = self.format_details_version_ordinal {
16249                return 1;
16250            }
16251            0
16252        }
16253    }
16254
16255    impl fidl::encoding::ValueTypeMarker for FormatDetails {
16256        type Borrowed<'a> = &'a Self;
16257        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16258            value
16259        }
16260    }
16261
16262    unsafe impl fidl::encoding::TypeMarker for FormatDetails {
16263        type Owned = Self;
16264
16265        #[inline(always)]
16266        fn inline_align(_context: fidl::encoding::Context) -> usize {
16267            8
16268        }
16269
16270        #[inline(always)]
16271        fn inline_size(_context: fidl::encoding::Context) -> usize {
16272            16
16273        }
16274    }
16275
16276    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatDetails, D>
16277        for &FormatDetails
16278    {
16279        unsafe fn encode(
16280            self,
16281            encoder: &mut fidl::encoding::Encoder<'_, D>,
16282            offset: usize,
16283            mut depth: fidl::encoding::Depth,
16284        ) -> fidl::Result<()> {
16285            encoder.debug_check_bounds::<FormatDetails>(offset);
16286            // Vector header
16287            let max_ordinal: u64 = self.max_ordinal_present();
16288            encoder.write_num(max_ordinal, offset);
16289            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16290            // Calling encoder.out_of_line_offset(0) is not allowed.
16291            if max_ordinal == 0 {
16292                return Ok(());
16293            }
16294            depth.increment()?;
16295            let envelope_size = 8;
16296            let bytes_len = max_ordinal as usize * envelope_size;
16297            #[allow(unused_variables)]
16298            let offset = encoder.out_of_line_offset(bytes_len);
16299            let mut _prev_end_offset: usize = 0;
16300            if 1 > max_ordinal {
16301                return Ok(());
16302            }
16303
16304            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16305            // are envelope_size bytes.
16306            let cur_offset: usize = (1 - 1) * envelope_size;
16307
16308            // Zero reserved fields.
16309            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16310
16311            // Safety:
16312            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16313            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16314            //   envelope_size bytes, there is always sufficient room.
16315            fidl::encoding::encode_in_envelope_optional::<u64, D>(
16316                self.format_details_version_ordinal
16317                    .as_ref()
16318                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16319                encoder,
16320                offset + cur_offset,
16321                depth,
16322            )?;
16323
16324            _prev_end_offset = cur_offset + envelope_size;
16325            if 2 > max_ordinal {
16326                return Ok(());
16327            }
16328
16329            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16330            // are envelope_size bytes.
16331            let cur_offset: usize = (2 - 1) * envelope_size;
16332
16333            // Zero reserved fields.
16334            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16335
16336            // Safety:
16337            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16338            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16339            //   envelope_size bytes, there is always sufficient room.
16340            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
16341                self.mime_type.as_ref().map(
16342                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
16343                ),
16344                encoder,
16345                offset + cur_offset,
16346                depth,
16347            )?;
16348
16349            _prev_end_offset = cur_offset + envelope_size;
16350            if 3 > max_ordinal {
16351                return Ok(());
16352            }
16353
16354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16355            // are envelope_size bytes.
16356            let cur_offset: usize = (3 - 1) * envelope_size;
16357
16358            // Zero reserved fields.
16359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16360
16361            // Safety:
16362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16364            //   envelope_size bytes, there is always sufficient room.
16365            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
16366            self.oob_bytes.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
16367            encoder, offset + cur_offset, depth
16368        )?;
16369
16370            _prev_end_offset = cur_offset + envelope_size;
16371            if 4 > max_ordinal {
16372                return Ok(());
16373            }
16374
16375            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16376            // are envelope_size bytes.
16377            let cur_offset: usize = (4 - 1) * envelope_size;
16378
16379            // Zero reserved fields.
16380            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16381
16382            // Safety:
16383            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16384            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16385            //   envelope_size bytes, there is always sufficient room.
16386            fidl::encoding::encode_in_envelope_optional::<DomainFormat, D>(
16387                self.domain.as_ref().map(<DomainFormat as fidl::encoding::ValueTypeMarker>::borrow),
16388                encoder,
16389                offset + cur_offset,
16390                depth,
16391            )?;
16392
16393            _prev_end_offset = cur_offset + envelope_size;
16394            if 5 > max_ordinal {
16395                return Ok(());
16396            }
16397
16398            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16399            // are envelope_size bytes.
16400            let cur_offset: usize = (5 - 1) * envelope_size;
16401
16402            // Zero reserved fields.
16403            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16404
16405            // Safety:
16406            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16407            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16408            //   envelope_size bytes, there is always sufficient room.
16409            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Parameter>, D>(
16410            self.pass_through_parameters.as_ref().map(<fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::ValueTypeMarker>::borrow),
16411            encoder, offset + cur_offset, depth
16412        )?;
16413
16414            _prev_end_offset = cur_offset + envelope_size;
16415            if 6 > max_ordinal {
16416                return Ok(());
16417            }
16418
16419            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16420            // are envelope_size bytes.
16421            let cur_offset: usize = (6 - 1) * envelope_size;
16422
16423            // Zero reserved fields.
16424            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16425
16426            // Safety:
16427            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16428            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16429            //   envelope_size bytes, there is always sufficient room.
16430            fidl::encoding::encode_in_envelope_optional::<EncoderSettings, D>(
16431                self.encoder_settings
16432                    .as_ref()
16433                    .map(<EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow),
16434                encoder,
16435                offset + cur_offset,
16436                depth,
16437            )?;
16438
16439            _prev_end_offset = cur_offset + envelope_size;
16440            if 7 > max_ordinal {
16441                return Ok(());
16442            }
16443
16444            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16445            // are envelope_size bytes.
16446            let cur_offset: usize = (7 - 1) * envelope_size;
16447
16448            // Zero reserved fields.
16449            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16450
16451            // Safety:
16452            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16453            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16454            //   envelope_size bytes, there is always sufficient room.
16455            fidl::encoding::encode_in_envelope_optional::<u64, D>(
16456                self.timebase.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
16457                encoder,
16458                offset + cur_offset,
16459                depth,
16460            )?;
16461
16462            _prev_end_offset = cur_offset + envelope_size;
16463            if 8 > max_ordinal {
16464                return Ok(());
16465            }
16466
16467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16468            // are envelope_size bytes.
16469            let cur_offset: usize = (8 - 1) * envelope_size;
16470
16471            // Zero reserved fields.
16472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16473
16474            // Safety:
16475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16477            //   envelope_size bytes, there is always sufficient room.
16478            fidl::encoding::encode_in_envelope_optional::<CodecProfile, D>(
16479                self.profile
16480                    .as_ref()
16481                    .map(<CodecProfile as fidl::encoding::ValueTypeMarker>::borrow),
16482                encoder,
16483                offset + cur_offset,
16484                depth,
16485            )?;
16486
16487            _prev_end_offset = cur_offset + envelope_size;
16488
16489            Ok(())
16490        }
16491    }
16492
16493    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatDetails {
16494        #[inline(always)]
16495        fn new_empty() -> Self {
16496            Self::default()
16497        }
16498
16499        unsafe fn decode(
16500            &mut self,
16501            decoder: &mut fidl::encoding::Decoder<'_, D>,
16502            offset: usize,
16503            mut depth: fidl::encoding::Depth,
16504        ) -> fidl::Result<()> {
16505            decoder.debug_check_bounds::<Self>(offset);
16506            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16507                None => return Err(fidl::Error::NotNullable),
16508                Some(len) => len,
16509            };
16510            // Calling decoder.out_of_line_offset(0) is not allowed.
16511            if len == 0 {
16512                return Ok(());
16513            };
16514            depth.increment()?;
16515            let envelope_size = 8;
16516            let bytes_len = len * envelope_size;
16517            let offset = decoder.out_of_line_offset(bytes_len)?;
16518            // Decode the envelope for each type.
16519            let mut _next_ordinal_to_read = 0;
16520            let mut next_offset = offset;
16521            let end_offset = offset + bytes_len;
16522            _next_ordinal_to_read += 1;
16523            if next_offset >= end_offset {
16524                return Ok(());
16525            }
16526
16527            // Decode unknown envelopes for gaps in ordinals.
16528            while _next_ordinal_to_read < 1 {
16529                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16530                _next_ordinal_to_read += 1;
16531                next_offset += envelope_size;
16532            }
16533
16534            let next_out_of_line = decoder.next_out_of_line();
16535            let handles_before = decoder.remaining_handles();
16536            if let Some((inlined, num_bytes, num_handles)) =
16537                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16538            {
16539                let member_inline_size =
16540                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16541                if inlined != (member_inline_size <= 4) {
16542                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16543                }
16544                let inner_offset;
16545                let mut inner_depth = depth.clone();
16546                if inlined {
16547                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16548                    inner_offset = next_offset;
16549                } else {
16550                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16551                    inner_depth.increment()?;
16552                }
16553                let val_ref = self
16554                    .format_details_version_ordinal
16555                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
16556                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16557                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16558                {
16559                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16560                }
16561                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16562                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16563                }
16564            }
16565
16566            next_offset += envelope_size;
16567            _next_ordinal_to_read += 1;
16568            if next_offset >= end_offset {
16569                return Ok(());
16570            }
16571
16572            // Decode unknown envelopes for gaps in ordinals.
16573            while _next_ordinal_to_read < 2 {
16574                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16575                _next_ordinal_to_read += 1;
16576                next_offset += envelope_size;
16577            }
16578
16579            let next_out_of_line = decoder.next_out_of_line();
16580            let handles_before = decoder.remaining_handles();
16581            if let Some((inlined, num_bytes, num_handles)) =
16582                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16583            {
16584                let member_inline_size =
16585                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
16586                        decoder.context,
16587                    );
16588                if inlined != (member_inline_size <= 4) {
16589                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16590                }
16591                let inner_offset;
16592                let mut inner_depth = depth.clone();
16593                if inlined {
16594                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16595                    inner_offset = next_offset;
16596                } else {
16597                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16598                    inner_depth.increment()?;
16599                }
16600                let val_ref = self
16601                    .mime_type
16602                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
16603                fidl::decode!(
16604                    fidl::encoding::UnboundedString,
16605                    D,
16606                    val_ref,
16607                    decoder,
16608                    inner_offset,
16609                    inner_depth
16610                )?;
16611                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16612                {
16613                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16614                }
16615                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16616                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16617                }
16618            }
16619
16620            next_offset += envelope_size;
16621            _next_ordinal_to_read += 1;
16622            if next_offset >= end_offset {
16623                return Ok(());
16624            }
16625
16626            // Decode unknown envelopes for gaps in ordinals.
16627            while _next_ordinal_to_read < 3 {
16628                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16629                _next_ordinal_to_read += 1;
16630                next_offset += envelope_size;
16631            }
16632
16633            let next_out_of_line = decoder.next_out_of_line();
16634            let handles_before = decoder.remaining_handles();
16635            if let Some((inlined, num_bytes, num_handles)) =
16636                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16637            {
16638                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16639                if inlined != (member_inline_size <= 4) {
16640                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16641                }
16642                let inner_offset;
16643                let mut inner_depth = depth.clone();
16644                if inlined {
16645                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16646                    inner_offset = next_offset;
16647                } else {
16648                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16649                    inner_depth.increment()?;
16650                }
16651                let val_ref = self.oob_bytes.get_or_insert_with(|| {
16652                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
16653                });
16654                fidl::decode!(
16655                    fidl::encoding::UnboundedVector<u8>,
16656                    D,
16657                    val_ref,
16658                    decoder,
16659                    inner_offset,
16660                    inner_depth
16661                )?;
16662                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16663                {
16664                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16665                }
16666                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16667                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16668                }
16669            }
16670
16671            next_offset += envelope_size;
16672            _next_ordinal_to_read += 1;
16673            if next_offset >= end_offset {
16674                return Ok(());
16675            }
16676
16677            // Decode unknown envelopes for gaps in ordinals.
16678            while _next_ordinal_to_read < 4 {
16679                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16680                _next_ordinal_to_read += 1;
16681                next_offset += envelope_size;
16682            }
16683
16684            let next_out_of_line = decoder.next_out_of_line();
16685            let handles_before = decoder.remaining_handles();
16686            if let Some((inlined, num_bytes, num_handles)) =
16687                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16688            {
16689                let member_inline_size =
16690                    <DomainFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16691                if inlined != (member_inline_size <= 4) {
16692                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16693                }
16694                let inner_offset;
16695                let mut inner_depth = depth.clone();
16696                if inlined {
16697                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16698                    inner_offset = next_offset;
16699                } else {
16700                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16701                    inner_depth.increment()?;
16702                }
16703                let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(DomainFormat, D));
16704                fidl::decode!(DomainFormat, D, val_ref, decoder, inner_offset, inner_depth)?;
16705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16706                {
16707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16708                }
16709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16711                }
16712            }
16713
16714            next_offset += envelope_size;
16715            _next_ordinal_to_read += 1;
16716            if next_offset >= end_offset {
16717                return Ok(());
16718            }
16719
16720            // Decode unknown envelopes for gaps in ordinals.
16721            while _next_ordinal_to_read < 5 {
16722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16723                _next_ordinal_to_read += 1;
16724                next_offset += envelope_size;
16725            }
16726
16727            let next_out_of_line = decoder.next_out_of_line();
16728            let handles_before = decoder.remaining_handles();
16729            if let Some((inlined, num_bytes, num_handles)) =
16730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16731            {
16732                let member_inline_size = <fidl::encoding::UnboundedVector<Parameter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16733                if inlined != (member_inline_size <= 4) {
16734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16735                }
16736                let inner_offset;
16737                let mut inner_depth = depth.clone();
16738                if inlined {
16739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16740                    inner_offset = next_offset;
16741                } else {
16742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16743                    inner_depth.increment()?;
16744                }
16745                let val_ref = self.pass_through_parameters.get_or_insert_with(|| {
16746                    fidl::new_empty!(fidl::encoding::UnboundedVector<Parameter>, D)
16747                });
16748                fidl::decode!(
16749                    fidl::encoding::UnboundedVector<Parameter>,
16750                    D,
16751                    val_ref,
16752                    decoder,
16753                    inner_offset,
16754                    inner_depth
16755                )?;
16756                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16757                {
16758                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16759                }
16760                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16761                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16762                }
16763            }
16764
16765            next_offset += envelope_size;
16766            _next_ordinal_to_read += 1;
16767            if next_offset >= end_offset {
16768                return Ok(());
16769            }
16770
16771            // Decode unknown envelopes for gaps in ordinals.
16772            while _next_ordinal_to_read < 6 {
16773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16774                _next_ordinal_to_read += 1;
16775                next_offset += envelope_size;
16776            }
16777
16778            let next_out_of_line = decoder.next_out_of_line();
16779            let handles_before = decoder.remaining_handles();
16780            if let Some((inlined, num_bytes, num_handles)) =
16781                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16782            {
16783                let member_inline_size =
16784                    <EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16785                if inlined != (member_inline_size <= 4) {
16786                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16787                }
16788                let inner_offset;
16789                let mut inner_depth = depth.clone();
16790                if inlined {
16791                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16792                    inner_offset = next_offset;
16793                } else {
16794                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16795                    inner_depth.increment()?;
16796                }
16797                let val_ref = self
16798                    .encoder_settings
16799                    .get_or_insert_with(|| fidl::new_empty!(EncoderSettings, D));
16800                fidl::decode!(EncoderSettings, D, val_ref, decoder, inner_offset, inner_depth)?;
16801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16802                {
16803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16804                }
16805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16807                }
16808            }
16809
16810            next_offset += envelope_size;
16811            _next_ordinal_to_read += 1;
16812            if next_offset >= end_offset {
16813                return Ok(());
16814            }
16815
16816            // Decode unknown envelopes for gaps in ordinals.
16817            while _next_ordinal_to_read < 7 {
16818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16819                _next_ordinal_to_read += 1;
16820                next_offset += envelope_size;
16821            }
16822
16823            let next_out_of_line = decoder.next_out_of_line();
16824            let handles_before = decoder.remaining_handles();
16825            if let Some((inlined, num_bytes, num_handles)) =
16826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16827            {
16828                let member_inline_size =
16829                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16830                if inlined != (member_inline_size <= 4) {
16831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16832                }
16833                let inner_offset;
16834                let mut inner_depth = depth.clone();
16835                if inlined {
16836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16837                    inner_offset = next_offset;
16838                } else {
16839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16840                    inner_depth.increment()?;
16841                }
16842                let val_ref = self.timebase.get_or_insert_with(|| fidl::new_empty!(u64, D));
16843                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
16844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16845                {
16846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16847                }
16848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16850                }
16851            }
16852
16853            next_offset += envelope_size;
16854            _next_ordinal_to_read += 1;
16855            if next_offset >= end_offset {
16856                return Ok(());
16857            }
16858
16859            // Decode unknown envelopes for gaps in ordinals.
16860            while _next_ordinal_to_read < 8 {
16861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16862                _next_ordinal_to_read += 1;
16863                next_offset += envelope_size;
16864            }
16865
16866            let next_out_of_line = decoder.next_out_of_line();
16867            let handles_before = decoder.remaining_handles();
16868            if let Some((inlined, num_bytes, num_handles)) =
16869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16870            {
16871                let member_inline_size =
16872                    <CodecProfile as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16873                if inlined != (member_inline_size <= 4) {
16874                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16875                }
16876                let inner_offset;
16877                let mut inner_depth = depth.clone();
16878                if inlined {
16879                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16880                    inner_offset = next_offset;
16881                } else {
16882                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16883                    inner_depth.increment()?;
16884                }
16885                let val_ref = self.profile.get_or_insert_with(|| fidl::new_empty!(CodecProfile, D));
16886                fidl::decode!(CodecProfile, D, val_ref, decoder, inner_offset, inner_depth)?;
16887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16888                {
16889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16890                }
16891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16893                }
16894            }
16895
16896            next_offset += envelope_size;
16897
16898            // Decode the remaining unknown envelopes.
16899            while next_offset < end_offset {
16900                _next_ordinal_to_read += 1;
16901                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16902                next_offset += envelope_size;
16903            }
16904
16905            Ok(())
16906        }
16907    }
16908
16909    impl H264EncoderSettings {
16910        #[inline(always)]
16911        fn max_ordinal_present(&self) -> u64 {
16912            if let Some(_) = self.quantization_params {
16913                return 7;
16914            }
16915            if let Some(_) = self.force_key_frame {
16916                return 6;
16917            }
16918            if let Some(_) = self.min_frame_rate {
16919                return 5;
16920            }
16921            if let Some(_) = self.variable_frame_rate {
16922                return 4;
16923            }
16924            if let Some(_) = self.gop_size {
16925                return 3;
16926            }
16927            if let Some(_) = self.frame_rate {
16928                return 2;
16929            }
16930            if let Some(_) = self.bit_rate {
16931                return 1;
16932            }
16933            0
16934        }
16935    }
16936
16937    impl fidl::encoding::ValueTypeMarker for H264EncoderSettings {
16938        type Borrowed<'a> = &'a Self;
16939        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16940            value
16941        }
16942    }
16943
16944    unsafe impl fidl::encoding::TypeMarker for H264EncoderSettings {
16945        type Owned = Self;
16946
16947        #[inline(always)]
16948        fn inline_align(_context: fidl::encoding::Context) -> usize {
16949            8
16950        }
16951
16952        #[inline(always)]
16953        fn inline_size(_context: fidl::encoding::Context) -> usize {
16954            16
16955        }
16956    }
16957
16958    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<H264EncoderSettings, D>
16959        for &H264EncoderSettings
16960    {
16961        unsafe fn encode(
16962            self,
16963            encoder: &mut fidl::encoding::Encoder<'_, D>,
16964            offset: usize,
16965            mut depth: fidl::encoding::Depth,
16966        ) -> fidl::Result<()> {
16967            encoder.debug_check_bounds::<H264EncoderSettings>(offset);
16968            // Vector header
16969            let max_ordinal: u64 = self.max_ordinal_present();
16970            encoder.write_num(max_ordinal, offset);
16971            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16972            // Calling encoder.out_of_line_offset(0) is not allowed.
16973            if max_ordinal == 0 {
16974                return Ok(());
16975            }
16976            depth.increment()?;
16977            let envelope_size = 8;
16978            let bytes_len = max_ordinal as usize * envelope_size;
16979            #[allow(unused_variables)]
16980            let offset = encoder.out_of_line_offset(bytes_len);
16981            let mut _prev_end_offset: usize = 0;
16982            if 1 > max_ordinal {
16983                return Ok(());
16984            }
16985
16986            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16987            // are envelope_size bytes.
16988            let cur_offset: usize = (1 - 1) * envelope_size;
16989
16990            // Zero reserved fields.
16991            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16992
16993            // Safety:
16994            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16995            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16996            //   envelope_size bytes, there is always sufficient room.
16997            fidl::encoding::encode_in_envelope_optional::<u32, D>(
16998                self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
16999                encoder,
17000                offset + cur_offset,
17001                depth,
17002            )?;
17003
17004            _prev_end_offset = cur_offset + envelope_size;
17005            if 2 > max_ordinal {
17006                return Ok(());
17007            }
17008
17009            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17010            // are envelope_size bytes.
17011            let cur_offset: usize = (2 - 1) * envelope_size;
17012
17013            // Zero reserved fields.
17014            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17015
17016            // Safety:
17017            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17018            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17019            //   envelope_size bytes, there is always sufficient room.
17020            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17021                self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17022                encoder,
17023                offset + cur_offset,
17024                depth,
17025            )?;
17026
17027            _prev_end_offset = cur_offset + envelope_size;
17028            if 3 > max_ordinal {
17029                return Ok(());
17030            }
17031
17032            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17033            // are envelope_size bytes.
17034            let cur_offset: usize = (3 - 1) * envelope_size;
17035
17036            // Zero reserved fields.
17037            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17038
17039            // Safety:
17040            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17041            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17042            //   envelope_size bytes, there is always sufficient room.
17043            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17044                self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17045                encoder,
17046                offset + cur_offset,
17047                depth,
17048            )?;
17049
17050            _prev_end_offset = cur_offset + envelope_size;
17051            if 4 > max_ordinal {
17052                return Ok(());
17053            }
17054
17055            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17056            // are envelope_size bytes.
17057            let cur_offset: usize = (4 - 1) * envelope_size;
17058
17059            // Zero reserved fields.
17060            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17061
17062            // Safety:
17063            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17064            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17065            //   envelope_size bytes, there is always sufficient room.
17066            fidl::encoding::encode_in_envelope_optional::<bool, D>(
17067                self.variable_frame_rate
17068                    .as_ref()
17069                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
17070                encoder,
17071                offset + cur_offset,
17072                depth,
17073            )?;
17074
17075            _prev_end_offset = cur_offset + envelope_size;
17076            if 5 > max_ordinal {
17077                return Ok(());
17078            }
17079
17080            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17081            // are envelope_size bytes.
17082            let cur_offset: usize = (5 - 1) * envelope_size;
17083
17084            // Zero reserved fields.
17085            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17086
17087            // Safety:
17088            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17089            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17090            //   envelope_size bytes, there is always sufficient room.
17091            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17092                self.min_frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17093                encoder,
17094                offset + cur_offset,
17095                depth,
17096            )?;
17097
17098            _prev_end_offset = cur_offset + envelope_size;
17099            if 6 > max_ordinal {
17100                return Ok(());
17101            }
17102
17103            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17104            // are envelope_size bytes.
17105            let cur_offset: usize = (6 - 1) * envelope_size;
17106
17107            // Zero reserved fields.
17108            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17109
17110            // Safety:
17111            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17112            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17113            //   envelope_size bytes, there is always sufficient room.
17114            fidl::encoding::encode_in_envelope_optional::<bool, D>(
17115                self.force_key_frame
17116                    .as_ref()
17117                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
17118                encoder,
17119                offset + cur_offset,
17120                depth,
17121            )?;
17122
17123            _prev_end_offset = cur_offset + envelope_size;
17124            if 7 > max_ordinal {
17125                return Ok(());
17126            }
17127
17128            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17129            // are envelope_size bytes.
17130            let cur_offset: usize = (7 - 1) * envelope_size;
17131
17132            // Zero reserved fields.
17133            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17134
17135            // Safety:
17136            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17137            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17138            //   envelope_size bytes, there is always sufficient room.
17139            fidl::encoding::encode_in_envelope_optional::<H264QuantizationParameters, D>(
17140                self.quantization_params
17141                    .as_ref()
17142                    .map(<H264QuantizationParameters as fidl::encoding::ValueTypeMarker>::borrow),
17143                encoder,
17144                offset + cur_offset,
17145                depth,
17146            )?;
17147
17148            _prev_end_offset = cur_offset + envelope_size;
17149
17150            Ok(())
17151        }
17152    }
17153
17154    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for H264EncoderSettings {
17155        #[inline(always)]
17156        fn new_empty() -> Self {
17157            Self::default()
17158        }
17159
17160        unsafe fn decode(
17161            &mut self,
17162            decoder: &mut fidl::encoding::Decoder<'_, D>,
17163            offset: usize,
17164            mut depth: fidl::encoding::Depth,
17165        ) -> fidl::Result<()> {
17166            decoder.debug_check_bounds::<Self>(offset);
17167            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17168                None => return Err(fidl::Error::NotNullable),
17169                Some(len) => len,
17170            };
17171            // Calling decoder.out_of_line_offset(0) is not allowed.
17172            if len == 0 {
17173                return Ok(());
17174            };
17175            depth.increment()?;
17176            let envelope_size = 8;
17177            let bytes_len = len * envelope_size;
17178            let offset = decoder.out_of_line_offset(bytes_len)?;
17179            // Decode the envelope for each type.
17180            let mut _next_ordinal_to_read = 0;
17181            let mut next_offset = offset;
17182            let end_offset = offset + bytes_len;
17183            _next_ordinal_to_read += 1;
17184            if next_offset >= end_offset {
17185                return Ok(());
17186            }
17187
17188            // Decode unknown envelopes for gaps in ordinals.
17189            while _next_ordinal_to_read < 1 {
17190                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17191                _next_ordinal_to_read += 1;
17192                next_offset += envelope_size;
17193            }
17194
17195            let next_out_of_line = decoder.next_out_of_line();
17196            let handles_before = decoder.remaining_handles();
17197            if let Some((inlined, num_bytes, num_handles)) =
17198                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17199            {
17200                let member_inline_size =
17201                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17202                if inlined != (member_inline_size <= 4) {
17203                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17204                }
17205                let inner_offset;
17206                let mut inner_depth = depth.clone();
17207                if inlined {
17208                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17209                    inner_offset = next_offset;
17210                } else {
17211                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17212                    inner_depth.increment()?;
17213                }
17214                let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17215                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17216                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17217                {
17218                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17219                }
17220                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17221                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17222                }
17223            }
17224
17225            next_offset += envelope_size;
17226            _next_ordinal_to_read += 1;
17227            if next_offset >= end_offset {
17228                return Ok(());
17229            }
17230
17231            // Decode unknown envelopes for gaps in ordinals.
17232            while _next_ordinal_to_read < 2 {
17233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17234                _next_ordinal_to_read += 1;
17235                next_offset += envelope_size;
17236            }
17237
17238            let next_out_of_line = decoder.next_out_of_line();
17239            let handles_before = decoder.remaining_handles();
17240            if let Some((inlined, num_bytes, num_handles)) =
17241                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17242            {
17243                let member_inline_size =
17244                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17245                if inlined != (member_inline_size <= 4) {
17246                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17247                }
17248                let inner_offset;
17249                let mut inner_depth = depth.clone();
17250                if inlined {
17251                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17252                    inner_offset = next_offset;
17253                } else {
17254                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17255                    inner_depth.increment()?;
17256                }
17257                let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17258                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17259                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17260                {
17261                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17262                }
17263                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17264                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17265                }
17266            }
17267
17268            next_offset += envelope_size;
17269            _next_ordinal_to_read += 1;
17270            if next_offset >= end_offset {
17271                return Ok(());
17272            }
17273
17274            // Decode unknown envelopes for gaps in ordinals.
17275            while _next_ordinal_to_read < 3 {
17276                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17277                _next_ordinal_to_read += 1;
17278                next_offset += envelope_size;
17279            }
17280
17281            let next_out_of_line = decoder.next_out_of_line();
17282            let handles_before = decoder.remaining_handles();
17283            if let Some((inlined, num_bytes, num_handles)) =
17284                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17285            {
17286                let member_inline_size =
17287                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17288                if inlined != (member_inline_size <= 4) {
17289                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17290                }
17291                let inner_offset;
17292                let mut inner_depth = depth.clone();
17293                if inlined {
17294                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17295                    inner_offset = next_offset;
17296                } else {
17297                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17298                    inner_depth.increment()?;
17299                }
17300                let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
17301                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17302                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17303                {
17304                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17305                }
17306                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17307                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17308                }
17309            }
17310
17311            next_offset += envelope_size;
17312            _next_ordinal_to_read += 1;
17313            if next_offset >= end_offset {
17314                return Ok(());
17315            }
17316
17317            // Decode unknown envelopes for gaps in ordinals.
17318            while _next_ordinal_to_read < 4 {
17319                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17320                _next_ordinal_to_read += 1;
17321                next_offset += envelope_size;
17322            }
17323
17324            let next_out_of_line = decoder.next_out_of_line();
17325            let handles_before = decoder.remaining_handles();
17326            if let Some((inlined, num_bytes, num_handles)) =
17327                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17328            {
17329                let member_inline_size =
17330                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17331                if inlined != (member_inline_size <= 4) {
17332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17333                }
17334                let inner_offset;
17335                let mut inner_depth = depth.clone();
17336                if inlined {
17337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17338                    inner_offset = next_offset;
17339                } else {
17340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17341                    inner_depth.increment()?;
17342                }
17343                let val_ref =
17344                    self.variable_frame_rate.get_or_insert_with(|| fidl::new_empty!(bool, D));
17345                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17346                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17347                {
17348                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17349                }
17350                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17351                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17352                }
17353            }
17354
17355            next_offset += envelope_size;
17356            _next_ordinal_to_read += 1;
17357            if next_offset >= end_offset {
17358                return Ok(());
17359            }
17360
17361            // Decode unknown envelopes for gaps in ordinals.
17362            while _next_ordinal_to_read < 5 {
17363                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17364                _next_ordinal_to_read += 1;
17365                next_offset += envelope_size;
17366            }
17367
17368            let next_out_of_line = decoder.next_out_of_line();
17369            let handles_before = decoder.remaining_handles();
17370            if let Some((inlined, num_bytes, num_handles)) =
17371                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17372            {
17373                let member_inline_size =
17374                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17375                if inlined != (member_inline_size <= 4) {
17376                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17377                }
17378                let inner_offset;
17379                let mut inner_depth = depth.clone();
17380                if inlined {
17381                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17382                    inner_offset = next_offset;
17383                } else {
17384                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17385                    inner_depth.increment()?;
17386                }
17387                let val_ref = self.min_frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
17388                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17389                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17390                {
17391                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17392                }
17393                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17394                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17395                }
17396            }
17397
17398            next_offset += envelope_size;
17399            _next_ordinal_to_read += 1;
17400            if next_offset >= end_offset {
17401                return Ok(());
17402            }
17403
17404            // Decode unknown envelopes for gaps in ordinals.
17405            while _next_ordinal_to_read < 6 {
17406                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17407                _next_ordinal_to_read += 1;
17408                next_offset += envelope_size;
17409            }
17410
17411            let next_out_of_line = decoder.next_out_of_line();
17412            let handles_before = decoder.remaining_handles();
17413            if let Some((inlined, num_bytes, num_handles)) =
17414                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17415            {
17416                let member_inline_size =
17417                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17418                if inlined != (member_inline_size <= 4) {
17419                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17420                }
17421                let inner_offset;
17422                let mut inner_depth = depth.clone();
17423                if inlined {
17424                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17425                    inner_offset = next_offset;
17426                } else {
17427                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17428                    inner_depth.increment()?;
17429                }
17430                let val_ref = self.force_key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
17431                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
17432                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17433                {
17434                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17435                }
17436                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17437                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17438                }
17439            }
17440
17441            next_offset += envelope_size;
17442            _next_ordinal_to_read += 1;
17443            if next_offset >= end_offset {
17444                return Ok(());
17445            }
17446
17447            // Decode unknown envelopes for gaps in ordinals.
17448            while _next_ordinal_to_read < 7 {
17449                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17450                _next_ordinal_to_read += 1;
17451                next_offset += envelope_size;
17452            }
17453
17454            let next_out_of_line = decoder.next_out_of_line();
17455            let handles_before = decoder.remaining_handles();
17456            if let Some((inlined, num_bytes, num_handles)) =
17457                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17458            {
17459                let member_inline_size =
17460                    <H264QuantizationParameters as fidl::encoding::TypeMarker>::inline_size(
17461                        decoder.context,
17462                    );
17463                if inlined != (member_inline_size <= 4) {
17464                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17465                }
17466                let inner_offset;
17467                let mut inner_depth = depth.clone();
17468                if inlined {
17469                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17470                    inner_offset = next_offset;
17471                } else {
17472                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17473                    inner_depth.increment()?;
17474                }
17475                let val_ref = self
17476                    .quantization_params
17477                    .get_or_insert_with(|| fidl::new_empty!(H264QuantizationParameters, D));
17478                fidl::decode!(
17479                    H264QuantizationParameters,
17480                    D,
17481                    val_ref,
17482                    decoder,
17483                    inner_offset,
17484                    inner_depth
17485                )?;
17486                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17487                {
17488                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17489                }
17490                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17491                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17492                }
17493            }
17494
17495            next_offset += envelope_size;
17496
17497            // Decode the remaining unknown envelopes.
17498            while next_offset < end_offset {
17499                _next_ordinal_to_read += 1;
17500                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17501                next_offset += envelope_size;
17502            }
17503
17504            Ok(())
17505        }
17506    }
17507
17508    impl H264QuantizationParameters {
17509        #[inline(always)]
17510        fn max_ordinal_present(&self) -> u64 {
17511            if let Some(_) = self.p_max {
17512                return 6;
17513            }
17514            if let Some(_) = self.p_min {
17515                return 5;
17516            }
17517            if let Some(_) = self.p_base {
17518                return 4;
17519            }
17520            if let Some(_) = self.i_max {
17521                return 3;
17522            }
17523            if let Some(_) = self.i_min {
17524                return 2;
17525            }
17526            if let Some(_) = self.i_base {
17527                return 1;
17528            }
17529            0
17530        }
17531    }
17532
17533    impl fidl::encoding::ValueTypeMarker for H264QuantizationParameters {
17534        type Borrowed<'a> = &'a Self;
17535        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17536            value
17537        }
17538    }
17539
17540    unsafe impl fidl::encoding::TypeMarker for H264QuantizationParameters {
17541        type Owned = Self;
17542
17543        #[inline(always)]
17544        fn inline_align(_context: fidl::encoding::Context) -> usize {
17545            8
17546        }
17547
17548        #[inline(always)]
17549        fn inline_size(_context: fidl::encoding::Context) -> usize {
17550            16
17551        }
17552    }
17553
17554    unsafe impl<D: fidl::encoding::ResourceDialect>
17555        fidl::encoding::Encode<H264QuantizationParameters, D> for &H264QuantizationParameters
17556    {
17557        unsafe fn encode(
17558            self,
17559            encoder: &mut fidl::encoding::Encoder<'_, D>,
17560            offset: usize,
17561            mut depth: fidl::encoding::Depth,
17562        ) -> fidl::Result<()> {
17563            encoder.debug_check_bounds::<H264QuantizationParameters>(offset);
17564            // Vector header
17565            let max_ordinal: u64 = self.max_ordinal_present();
17566            encoder.write_num(max_ordinal, offset);
17567            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17568            // Calling encoder.out_of_line_offset(0) is not allowed.
17569            if max_ordinal == 0 {
17570                return Ok(());
17571            }
17572            depth.increment()?;
17573            let envelope_size = 8;
17574            let bytes_len = max_ordinal as usize * envelope_size;
17575            #[allow(unused_variables)]
17576            let offset = encoder.out_of_line_offset(bytes_len);
17577            let mut _prev_end_offset: usize = 0;
17578            if 1 > max_ordinal {
17579                return Ok(());
17580            }
17581
17582            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17583            // are envelope_size bytes.
17584            let cur_offset: usize = (1 - 1) * envelope_size;
17585
17586            // Zero reserved fields.
17587            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17588
17589            // Safety:
17590            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17591            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17592            //   envelope_size bytes, there is always sufficient room.
17593            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17594                self.i_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17595                encoder,
17596                offset + cur_offset,
17597                depth,
17598            )?;
17599
17600            _prev_end_offset = cur_offset + envelope_size;
17601            if 2 > max_ordinal {
17602                return Ok(());
17603            }
17604
17605            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17606            // are envelope_size bytes.
17607            let cur_offset: usize = (2 - 1) * envelope_size;
17608
17609            // Zero reserved fields.
17610            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17611
17612            // Safety:
17613            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17614            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17615            //   envelope_size bytes, there is always sufficient room.
17616            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17617                self.i_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17618                encoder,
17619                offset + cur_offset,
17620                depth,
17621            )?;
17622
17623            _prev_end_offset = cur_offset + envelope_size;
17624            if 3 > max_ordinal {
17625                return Ok(());
17626            }
17627
17628            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17629            // are envelope_size bytes.
17630            let cur_offset: usize = (3 - 1) * envelope_size;
17631
17632            // Zero reserved fields.
17633            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17634
17635            // Safety:
17636            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17637            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17638            //   envelope_size bytes, there is always sufficient room.
17639            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17640                self.i_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17641                encoder,
17642                offset + cur_offset,
17643                depth,
17644            )?;
17645
17646            _prev_end_offset = cur_offset + envelope_size;
17647            if 4 > max_ordinal {
17648                return Ok(());
17649            }
17650
17651            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17652            // are envelope_size bytes.
17653            let cur_offset: usize = (4 - 1) * envelope_size;
17654
17655            // Zero reserved fields.
17656            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17657
17658            // Safety:
17659            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17660            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17661            //   envelope_size bytes, there is always sufficient room.
17662            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17663                self.p_base.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17664                encoder,
17665                offset + cur_offset,
17666                depth,
17667            )?;
17668
17669            _prev_end_offset = cur_offset + envelope_size;
17670            if 5 > max_ordinal {
17671                return Ok(());
17672            }
17673
17674            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17675            // are envelope_size bytes.
17676            let cur_offset: usize = (5 - 1) * envelope_size;
17677
17678            // Zero reserved fields.
17679            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17680
17681            // Safety:
17682            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17683            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17684            //   envelope_size bytes, there is always sufficient room.
17685            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17686                self.p_min.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17687                encoder,
17688                offset + cur_offset,
17689                depth,
17690            )?;
17691
17692            _prev_end_offset = cur_offset + envelope_size;
17693            if 6 > max_ordinal {
17694                return Ok(());
17695            }
17696
17697            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17698            // are envelope_size bytes.
17699            let cur_offset: usize = (6 - 1) * envelope_size;
17700
17701            // Zero reserved fields.
17702            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17703
17704            // Safety:
17705            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17706            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17707            //   envelope_size bytes, there is always sufficient room.
17708            fidl::encoding::encode_in_envelope_optional::<u32, D>(
17709                self.p_max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
17710                encoder,
17711                offset + cur_offset,
17712                depth,
17713            )?;
17714
17715            _prev_end_offset = cur_offset + envelope_size;
17716
17717            Ok(())
17718        }
17719    }
17720
17721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
17722        for H264QuantizationParameters
17723    {
17724        #[inline(always)]
17725        fn new_empty() -> Self {
17726            Self::default()
17727        }
17728
17729        unsafe fn decode(
17730            &mut self,
17731            decoder: &mut fidl::encoding::Decoder<'_, D>,
17732            offset: usize,
17733            mut depth: fidl::encoding::Depth,
17734        ) -> fidl::Result<()> {
17735            decoder.debug_check_bounds::<Self>(offset);
17736            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17737                None => return Err(fidl::Error::NotNullable),
17738                Some(len) => len,
17739            };
17740            // Calling decoder.out_of_line_offset(0) is not allowed.
17741            if len == 0 {
17742                return Ok(());
17743            };
17744            depth.increment()?;
17745            let envelope_size = 8;
17746            let bytes_len = len * envelope_size;
17747            let offset = decoder.out_of_line_offset(bytes_len)?;
17748            // Decode the envelope for each type.
17749            let mut _next_ordinal_to_read = 0;
17750            let mut next_offset = offset;
17751            let end_offset = offset + bytes_len;
17752            _next_ordinal_to_read += 1;
17753            if next_offset >= end_offset {
17754                return Ok(());
17755            }
17756
17757            // Decode unknown envelopes for gaps in ordinals.
17758            while _next_ordinal_to_read < 1 {
17759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17760                _next_ordinal_to_read += 1;
17761                next_offset += envelope_size;
17762            }
17763
17764            let next_out_of_line = decoder.next_out_of_line();
17765            let handles_before = decoder.remaining_handles();
17766            if let Some((inlined, num_bytes, num_handles)) =
17767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17768            {
17769                let member_inline_size =
17770                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17771                if inlined != (member_inline_size <= 4) {
17772                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17773                }
17774                let inner_offset;
17775                let mut inner_depth = depth.clone();
17776                if inlined {
17777                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17778                    inner_offset = next_offset;
17779                } else {
17780                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17781                    inner_depth.increment()?;
17782                }
17783                let val_ref = self.i_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17784                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17786                {
17787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17788                }
17789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17791                }
17792            }
17793
17794            next_offset += envelope_size;
17795            _next_ordinal_to_read += 1;
17796            if next_offset >= end_offset {
17797                return Ok(());
17798            }
17799
17800            // Decode unknown envelopes for gaps in ordinals.
17801            while _next_ordinal_to_read < 2 {
17802                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17803                _next_ordinal_to_read += 1;
17804                next_offset += envelope_size;
17805            }
17806
17807            let next_out_of_line = decoder.next_out_of_line();
17808            let handles_before = decoder.remaining_handles();
17809            if let Some((inlined, num_bytes, num_handles)) =
17810                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17811            {
17812                let member_inline_size =
17813                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17814                if inlined != (member_inline_size <= 4) {
17815                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17816                }
17817                let inner_offset;
17818                let mut inner_depth = depth.clone();
17819                if inlined {
17820                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17821                    inner_offset = next_offset;
17822                } else {
17823                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17824                    inner_depth.increment()?;
17825                }
17826                let val_ref = self.i_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17827                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17829                {
17830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17831                }
17832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17834                }
17835            }
17836
17837            next_offset += envelope_size;
17838            _next_ordinal_to_read += 1;
17839            if next_offset >= end_offset {
17840                return Ok(());
17841            }
17842
17843            // Decode unknown envelopes for gaps in ordinals.
17844            while _next_ordinal_to_read < 3 {
17845                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17846                _next_ordinal_to_read += 1;
17847                next_offset += envelope_size;
17848            }
17849
17850            let next_out_of_line = decoder.next_out_of_line();
17851            let handles_before = decoder.remaining_handles();
17852            if let Some((inlined, num_bytes, num_handles)) =
17853                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17854            {
17855                let member_inline_size =
17856                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17857                if inlined != (member_inline_size <= 4) {
17858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17859                }
17860                let inner_offset;
17861                let mut inner_depth = depth.clone();
17862                if inlined {
17863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17864                    inner_offset = next_offset;
17865                } else {
17866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17867                    inner_depth.increment()?;
17868                }
17869                let val_ref = self.i_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17870                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17872                {
17873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17874                }
17875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17877                }
17878            }
17879
17880            next_offset += envelope_size;
17881            _next_ordinal_to_read += 1;
17882            if next_offset >= end_offset {
17883                return Ok(());
17884            }
17885
17886            // Decode unknown envelopes for gaps in ordinals.
17887            while _next_ordinal_to_read < 4 {
17888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17889                _next_ordinal_to_read += 1;
17890                next_offset += envelope_size;
17891            }
17892
17893            let next_out_of_line = decoder.next_out_of_line();
17894            let handles_before = decoder.remaining_handles();
17895            if let Some((inlined, num_bytes, num_handles)) =
17896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17897            {
17898                let member_inline_size =
17899                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17900                if inlined != (member_inline_size <= 4) {
17901                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17902                }
17903                let inner_offset;
17904                let mut inner_depth = depth.clone();
17905                if inlined {
17906                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17907                    inner_offset = next_offset;
17908                } else {
17909                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17910                    inner_depth.increment()?;
17911                }
17912                let val_ref = self.p_base.get_or_insert_with(|| fidl::new_empty!(u32, D));
17913                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17915                {
17916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17917                }
17918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17920                }
17921            }
17922
17923            next_offset += envelope_size;
17924            _next_ordinal_to_read += 1;
17925            if next_offset >= end_offset {
17926                return Ok(());
17927            }
17928
17929            // Decode unknown envelopes for gaps in ordinals.
17930            while _next_ordinal_to_read < 5 {
17931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17932                _next_ordinal_to_read += 1;
17933                next_offset += envelope_size;
17934            }
17935
17936            let next_out_of_line = decoder.next_out_of_line();
17937            let handles_before = decoder.remaining_handles();
17938            if let Some((inlined, num_bytes, num_handles)) =
17939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17940            {
17941                let member_inline_size =
17942                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17943                if inlined != (member_inline_size <= 4) {
17944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17945                }
17946                let inner_offset;
17947                let mut inner_depth = depth.clone();
17948                if inlined {
17949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17950                    inner_offset = next_offset;
17951                } else {
17952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17953                    inner_depth.increment()?;
17954                }
17955                let val_ref = self.p_min.get_or_insert_with(|| fidl::new_empty!(u32, D));
17956                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
17957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17958                {
17959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17960                }
17961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17963                }
17964            }
17965
17966            next_offset += envelope_size;
17967            _next_ordinal_to_read += 1;
17968            if next_offset >= end_offset {
17969                return Ok(());
17970            }
17971
17972            // Decode unknown envelopes for gaps in ordinals.
17973            while _next_ordinal_to_read < 6 {
17974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17975                _next_ordinal_to_read += 1;
17976                next_offset += envelope_size;
17977            }
17978
17979            let next_out_of_line = decoder.next_out_of_line();
17980            let handles_before = decoder.remaining_handles();
17981            if let Some((inlined, num_bytes, num_handles)) =
17982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17983            {
17984                let member_inline_size =
17985                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17986                if inlined != (member_inline_size <= 4) {
17987                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17988                }
17989                let inner_offset;
17990                let mut inner_depth = depth.clone();
17991                if inlined {
17992                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17993                    inner_offset = next_offset;
17994                } else {
17995                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17996                    inner_depth.increment()?;
17997                }
17998                let val_ref = self.p_max.get_or_insert_with(|| fidl::new_empty!(u32, D));
17999                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18000                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18001                {
18002                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18003                }
18004                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18005                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18006                }
18007            }
18008
18009            next_offset += envelope_size;
18010
18011            // Decode the remaining unknown envelopes.
18012            while next_offset < end_offset {
18013                _next_ordinal_to_read += 1;
18014                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18015                next_offset += envelope_size;
18016            }
18017
18018            Ok(())
18019        }
18020    }
18021
18022    impl HevcEncoderSettings {
18023        #[inline(always)]
18024        fn max_ordinal_present(&self) -> u64 {
18025            if let Some(_) = self.gop_size {
18026                return 3;
18027            }
18028            if let Some(_) = self.frame_rate {
18029                return 2;
18030            }
18031            if let Some(_) = self.bit_rate {
18032                return 1;
18033            }
18034            0
18035        }
18036    }
18037
18038    impl fidl::encoding::ValueTypeMarker for HevcEncoderSettings {
18039        type Borrowed<'a> = &'a Self;
18040        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18041            value
18042        }
18043    }
18044
18045    unsafe impl fidl::encoding::TypeMarker for HevcEncoderSettings {
18046        type Owned = Self;
18047
18048        #[inline(always)]
18049        fn inline_align(_context: fidl::encoding::Context) -> usize {
18050            8
18051        }
18052
18053        #[inline(always)]
18054        fn inline_size(_context: fidl::encoding::Context) -> usize {
18055            16
18056        }
18057    }
18058
18059    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HevcEncoderSettings, D>
18060        for &HevcEncoderSettings
18061    {
18062        unsafe fn encode(
18063            self,
18064            encoder: &mut fidl::encoding::Encoder<'_, D>,
18065            offset: usize,
18066            mut depth: fidl::encoding::Depth,
18067        ) -> fidl::Result<()> {
18068            encoder.debug_check_bounds::<HevcEncoderSettings>(offset);
18069            // Vector header
18070            let max_ordinal: u64 = self.max_ordinal_present();
18071            encoder.write_num(max_ordinal, offset);
18072            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18073            // Calling encoder.out_of_line_offset(0) is not allowed.
18074            if max_ordinal == 0 {
18075                return Ok(());
18076            }
18077            depth.increment()?;
18078            let envelope_size = 8;
18079            let bytes_len = max_ordinal as usize * envelope_size;
18080            #[allow(unused_variables)]
18081            let offset = encoder.out_of_line_offset(bytes_len);
18082            let mut _prev_end_offset: usize = 0;
18083            if 1 > max_ordinal {
18084                return Ok(());
18085            }
18086
18087            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18088            // are envelope_size bytes.
18089            let cur_offset: usize = (1 - 1) * envelope_size;
18090
18091            // Zero reserved fields.
18092            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18093
18094            // Safety:
18095            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18096            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18097            //   envelope_size bytes, there is always sufficient room.
18098            fidl::encoding::encode_in_envelope_optional::<u32, D>(
18099                self.bit_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18100                encoder,
18101                offset + cur_offset,
18102                depth,
18103            )?;
18104
18105            _prev_end_offset = cur_offset + envelope_size;
18106            if 2 > max_ordinal {
18107                return Ok(());
18108            }
18109
18110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18111            // are envelope_size bytes.
18112            let cur_offset: usize = (2 - 1) * envelope_size;
18113
18114            // Zero reserved fields.
18115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18116
18117            // Safety:
18118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18120            //   envelope_size bytes, there is always sufficient room.
18121            fidl::encoding::encode_in_envelope_optional::<u32, D>(
18122                self.frame_rate.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18123                encoder,
18124                offset + cur_offset,
18125                depth,
18126            )?;
18127
18128            _prev_end_offset = cur_offset + envelope_size;
18129            if 3 > max_ordinal {
18130                return Ok(());
18131            }
18132
18133            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18134            // are envelope_size bytes.
18135            let cur_offset: usize = (3 - 1) * envelope_size;
18136
18137            // Zero reserved fields.
18138            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18139
18140            // Safety:
18141            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18142            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18143            //   envelope_size bytes, there is always sufficient room.
18144            fidl::encoding::encode_in_envelope_optional::<u32, D>(
18145                self.gop_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
18146                encoder,
18147                offset + cur_offset,
18148                depth,
18149            )?;
18150
18151            _prev_end_offset = cur_offset + envelope_size;
18152
18153            Ok(())
18154        }
18155    }
18156
18157    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HevcEncoderSettings {
18158        #[inline(always)]
18159        fn new_empty() -> Self {
18160            Self::default()
18161        }
18162
18163        unsafe fn decode(
18164            &mut self,
18165            decoder: &mut fidl::encoding::Decoder<'_, D>,
18166            offset: usize,
18167            mut depth: fidl::encoding::Depth,
18168        ) -> fidl::Result<()> {
18169            decoder.debug_check_bounds::<Self>(offset);
18170            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18171                None => return Err(fidl::Error::NotNullable),
18172                Some(len) => len,
18173            };
18174            // Calling decoder.out_of_line_offset(0) is not allowed.
18175            if len == 0 {
18176                return Ok(());
18177            };
18178            depth.increment()?;
18179            let envelope_size = 8;
18180            let bytes_len = len * envelope_size;
18181            let offset = decoder.out_of_line_offset(bytes_len)?;
18182            // Decode the envelope for each type.
18183            let mut _next_ordinal_to_read = 0;
18184            let mut next_offset = offset;
18185            let end_offset = offset + bytes_len;
18186            _next_ordinal_to_read += 1;
18187            if next_offset >= end_offset {
18188                return Ok(());
18189            }
18190
18191            // Decode unknown envelopes for gaps in ordinals.
18192            while _next_ordinal_to_read < 1 {
18193                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18194                _next_ordinal_to_read += 1;
18195                next_offset += envelope_size;
18196            }
18197
18198            let next_out_of_line = decoder.next_out_of_line();
18199            let handles_before = decoder.remaining_handles();
18200            if let Some((inlined, num_bytes, num_handles)) =
18201                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18202            {
18203                let member_inline_size =
18204                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18205                if inlined != (member_inline_size <= 4) {
18206                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18207                }
18208                let inner_offset;
18209                let mut inner_depth = depth.clone();
18210                if inlined {
18211                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18212                    inner_offset = next_offset;
18213                } else {
18214                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18215                    inner_depth.increment()?;
18216                }
18217                let val_ref = self.bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18218                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18220                {
18221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18222                }
18223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18225                }
18226            }
18227
18228            next_offset += envelope_size;
18229            _next_ordinal_to_read += 1;
18230            if next_offset >= end_offset {
18231                return Ok(());
18232            }
18233
18234            // Decode unknown envelopes for gaps in ordinals.
18235            while _next_ordinal_to_read < 2 {
18236                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18237                _next_ordinal_to_read += 1;
18238                next_offset += envelope_size;
18239            }
18240
18241            let next_out_of_line = decoder.next_out_of_line();
18242            let handles_before = decoder.remaining_handles();
18243            if let Some((inlined, num_bytes, num_handles)) =
18244                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18245            {
18246                let member_inline_size =
18247                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18248                if inlined != (member_inline_size <= 4) {
18249                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18250                }
18251                let inner_offset;
18252                let mut inner_depth = depth.clone();
18253                if inlined {
18254                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18255                    inner_offset = next_offset;
18256                } else {
18257                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18258                    inner_depth.increment()?;
18259                }
18260                let val_ref = self.frame_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
18261                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18262                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18263                {
18264                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18265                }
18266                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18267                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18268                }
18269            }
18270
18271            next_offset += envelope_size;
18272            _next_ordinal_to_read += 1;
18273            if next_offset >= end_offset {
18274                return Ok(());
18275            }
18276
18277            // Decode unknown envelopes for gaps in ordinals.
18278            while _next_ordinal_to_read < 3 {
18279                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18280                _next_ordinal_to_read += 1;
18281                next_offset += envelope_size;
18282            }
18283
18284            let next_out_of_line = decoder.next_out_of_line();
18285            let handles_before = decoder.remaining_handles();
18286            if let Some((inlined, num_bytes, num_handles)) =
18287                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18288            {
18289                let member_inline_size =
18290                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18291                if inlined != (member_inline_size <= 4) {
18292                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18293                }
18294                let inner_offset;
18295                let mut inner_depth = depth.clone();
18296                if inlined {
18297                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18298                    inner_offset = next_offset;
18299                } else {
18300                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18301                    inner_depth.increment()?;
18302                }
18303                let val_ref = self.gop_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
18304                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
18305                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18306                {
18307                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18308                }
18309                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18310                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18311                }
18312            }
18313
18314            next_offset += envelope_size;
18315
18316            // Decode the remaining unknown envelopes.
18317            while next_offset < end_offset {
18318                _next_ordinal_to_read += 1;
18319                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18320                next_offset += envelope_size;
18321            }
18322
18323            Ok(())
18324        }
18325    }
18326
18327    impl InputAudioCapturerConfiguration {
18328        #[inline(always)]
18329        fn max_ordinal_present(&self) -> u64 {
18330            if let Some(_) = self.usage2 {
18331                return 2;
18332            }
18333            if let Some(_) = self.usage {
18334                return 1;
18335            }
18336            0
18337        }
18338    }
18339
18340    impl fidl::encoding::ValueTypeMarker for InputAudioCapturerConfiguration {
18341        type Borrowed<'a> = &'a Self;
18342        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18343            value
18344        }
18345    }
18346
18347    unsafe impl fidl::encoding::TypeMarker for InputAudioCapturerConfiguration {
18348        type Owned = Self;
18349
18350        #[inline(always)]
18351        fn inline_align(_context: fidl::encoding::Context) -> usize {
18352            8
18353        }
18354
18355        #[inline(always)]
18356        fn inline_size(_context: fidl::encoding::Context) -> usize {
18357            16
18358        }
18359    }
18360
18361    unsafe impl<D: fidl::encoding::ResourceDialect>
18362        fidl::encoding::Encode<InputAudioCapturerConfiguration, D>
18363        for &InputAudioCapturerConfiguration
18364    {
18365        unsafe fn encode(
18366            self,
18367            encoder: &mut fidl::encoding::Encoder<'_, D>,
18368            offset: usize,
18369            mut depth: fidl::encoding::Depth,
18370        ) -> fidl::Result<()> {
18371            encoder.debug_check_bounds::<InputAudioCapturerConfiguration>(offset);
18372            // Vector header
18373            let max_ordinal: u64 = self.max_ordinal_present();
18374            encoder.write_num(max_ordinal, offset);
18375            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18376            // Calling encoder.out_of_line_offset(0) is not allowed.
18377            if max_ordinal == 0 {
18378                return Ok(());
18379            }
18380            depth.increment()?;
18381            let envelope_size = 8;
18382            let bytes_len = max_ordinal as usize * envelope_size;
18383            #[allow(unused_variables)]
18384            let offset = encoder.out_of_line_offset(bytes_len);
18385            let mut _prev_end_offset: usize = 0;
18386            if 1 > max_ordinal {
18387                return Ok(());
18388            }
18389
18390            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18391            // are envelope_size bytes.
18392            let cur_offset: usize = (1 - 1) * envelope_size;
18393
18394            // Zero reserved fields.
18395            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18396
18397            // Safety:
18398            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18399            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18400            //   envelope_size bytes, there is always sufficient room.
18401            fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage, D>(
18402                self.usage
18403                    .as_ref()
18404                    .map(<AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow),
18405                encoder,
18406                offset + cur_offset,
18407                depth,
18408            )?;
18409
18410            _prev_end_offset = cur_offset + envelope_size;
18411            if 2 > max_ordinal {
18412                return Ok(());
18413            }
18414
18415            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18416            // are envelope_size bytes.
18417            let cur_offset: usize = (2 - 1) * envelope_size;
18418
18419            // Zero reserved fields.
18420            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18421
18422            // Safety:
18423            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18424            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18425            //   envelope_size bytes, there is always sufficient room.
18426            fidl::encoding::encode_in_envelope_optional::<AudioCaptureUsage2, D>(
18427                self.usage2
18428                    .as_ref()
18429                    .map(<AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow),
18430                encoder,
18431                offset + cur_offset,
18432                depth,
18433            )?;
18434
18435            _prev_end_offset = cur_offset + envelope_size;
18436
18437            Ok(())
18438        }
18439    }
18440
18441    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18442        for InputAudioCapturerConfiguration
18443    {
18444        #[inline(always)]
18445        fn new_empty() -> Self {
18446            Self::default()
18447        }
18448
18449        unsafe fn decode(
18450            &mut self,
18451            decoder: &mut fidl::encoding::Decoder<'_, D>,
18452            offset: usize,
18453            mut depth: fidl::encoding::Depth,
18454        ) -> fidl::Result<()> {
18455            decoder.debug_check_bounds::<Self>(offset);
18456            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18457                None => return Err(fidl::Error::NotNullable),
18458                Some(len) => len,
18459            };
18460            // Calling decoder.out_of_line_offset(0) is not allowed.
18461            if len == 0 {
18462                return Ok(());
18463            };
18464            depth.increment()?;
18465            let envelope_size = 8;
18466            let bytes_len = len * envelope_size;
18467            let offset = decoder.out_of_line_offset(bytes_len)?;
18468            // Decode the envelope for each type.
18469            let mut _next_ordinal_to_read = 0;
18470            let mut next_offset = offset;
18471            let end_offset = offset + bytes_len;
18472            _next_ordinal_to_read += 1;
18473            if next_offset >= end_offset {
18474                return Ok(());
18475            }
18476
18477            // Decode unknown envelopes for gaps in ordinals.
18478            while _next_ordinal_to_read < 1 {
18479                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18480                _next_ordinal_to_read += 1;
18481                next_offset += envelope_size;
18482            }
18483
18484            let next_out_of_line = decoder.next_out_of_line();
18485            let handles_before = decoder.remaining_handles();
18486            if let Some((inlined, num_bytes, num_handles)) =
18487                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18488            {
18489                let member_inline_size =
18490                    <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18491                if inlined != (member_inline_size <= 4) {
18492                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18493                }
18494                let inner_offset;
18495                let mut inner_depth = depth.clone();
18496                if inlined {
18497                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18498                    inner_offset = next_offset;
18499                } else {
18500                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18501                    inner_depth.increment()?;
18502                }
18503                let val_ref =
18504                    self.usage.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage, D));
18505                fidl::decode!(AudioCaptureUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
18506                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18507                {
18508                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18509                }
18510                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18511                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18512                }
18513            }
18514
18515            next_offset += envelope_size;
18516            _next_ordinal_to_read += 1;
18517            if next_offset >= end_offset {
18518                return Ok(());
18519            }
18520
18521            // Decode unknown envelopes for gaps in ordinals.
18522            while _next_ordinal_to_read < 2 {
18523                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18524                _next_ordinal_to_read += 1;
18525                next_offset += envelope_size;
18526            }
18527
18528            let next_out_of_line = decoder.next_out_of_line();
18529            let handles_before = decoder.remaining_handles();
18530            if let Some((inlined, num_bytes, num_handles)) =
18531                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18532            {
18533                let member_inline_size =
18534                    <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(
18535                        decoder.context,
18536                    );
18537                if inlined != (member_inline_size <= 4) {
18538                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18539                }
18540                let inner_offset;
18541                let mut inner_depth = depth.clone();
18542                if inlined {
18543                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18544                    inner_offset = next_offset;
18545                } else {
18546                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18547                    inner_depth.increment()?;
18548                }
18549                let val_ref =
18550                    self.usage2.get_or_insert_with(|| fidl::new_empty!(AudioCaptureUsage2, D));
18551                fidl::decode!(AudioCaptureUsage2, D, val_ref, decoder, inner_offset, inner_depth)?;
18552                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18553                {
18554                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18555                }
18556                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18557                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18558                }
18559            }
18560
18561            next_offset += envelope_size;
18562
18563            // Decode the remaining unknown envelopes.
18564            while next_offset < end_offset {
18565                _next_ordinal_to_read += 1;
18566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18567                next_offset += envelope_size;
18568            }
18569
18570            Ok(())
18571        }
18572    }
18573
18574    impl Lc3EncoderSettings {
18575        #[inline(always)]
18576        fn max_ordinal_present(&self) -> u64 {
18577            if let Some(_) = self.frame_duration {
18578                return 2;
18579            }
18580            if let Some(_) = self.nbytes {
18581                return 1;
18582            }
18583            0
18584        }
18585    }
18586
18587    impl fidl::encoding::ValueTypeMarker for Lc3EncoderSettings {
18588        type Borrowed<'a> = &'a Self;
18589        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18590            value
18591        }
18592    }
18593
18594    unsafe impl fidl::encoding::TypeMarker for Lc3EncoderSettings {
18595        type Owned = Self;
18596
18597        #[inline(always)]
18598        fn inline_align(_context: fidl::encoding::Context) -> usize {
18599            8
18600        }
18601
18602        #[inline(always)]
18603        fn inline_size(_context: fidl::encoding::Context) -> usize {
18604            16
18605        }
18606    }
18607
18608    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Lc3EncoderSettings, D>
18609        for &Lc3EncoderSettings
18610    {
18611        unsafe fn encode(
18612            self,
18613            encoder: &mut fidl::encoding::Encoder<'_, D>,
18614            offset: usize,
18615            mut depth: fidl::encoding::Depth,
18616        ) -> fidl::Result<()> {
18617            encoder.debug_check_bounds::<Lc3EncoderSettings>(offset);
18618            // Vector header
18619            let max_ordinal: u64 = self.max_ordinal_present();
18620            encoder.write_num(max_ordinal, offset);
18621            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18622            // Calling encoder.out_of_line_offset(0) is not allowed.
18623            if max_ordinal == 0 {
18624                return Ok(());
18625            }
18626            depth.increment()?;
18627            let envelope_size = 8;
18628            let bytes_len = max_ordinal as usize * envelope_size;
18629            #[allow(unused_variables)]
18630            let offset = encoder.out_of_line_offset(bytes_len);
18631            let mut _prev_end_offset: usize = 0;
18632            if 1 > max_ordinal {
18633                return Ok(());
18634            }
18635
18636            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18637            // are envelope_size bytes.
18638            let cur_offset: usize = (1 - 1) * envelope_size;
18639
18640            // Zero reserved fields.
18641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18642
18643            // Safety:
18644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18646            //   envelope_size bytes, there is always sufficient room.
18647            fidl::encoding::encode_in_envelope_optional::<u16, D>(
18648                self.nbytes.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
18649                encoder,
18650                offset + cur_offset,
18651                depth,
18652            )?;
18653
18654            _prev_end_offset = cur_offset + envelope_size;
18655            if 2 > max_ordinal {
18656                return Ok(());
18657            }
18658
18659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18660            // are envelope_size bytes.
18661            let cur_offset: usize = (2 - 1) * envelope_size;
18662
18663            // Zero reserved fields.
18664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18665
18666            // Safety:
18667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18669            //   envelope_size bytes, there is always sufficient room.
18670            fidl::encoding::encode_in_envelope_optional::<Lc3FrameDuration, D>(
18671                self.frame_duration
18672                    .as_ref()
18673                    .map(<Lc3FrameDuration as fidl::encoding::ValueTypeMarker>::borrow),
18674                encoder,
18675                offset + cur_offset,
18676                depth,
18677            )?;
18678
18679            _prev_end_offset = cur_offset + envelope_size;
18680
18681            Ok(())
18682        }
18683    }
18684
18685    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Lc3EncoderSettings {
18686        #[inline(always)]
18687        fn new_empty() -> Self {
18688            Self::default()
18689        }
18690
18691        unsafe fn decode(
18692            &mut self,
18693            decoder: &mut fidl::encoding::Decoder<'_, D>,
18694            offset: usize,
18695            mut depth: fidl::encoding::Depth,
18696        ) -> fidl::Result<()> {
18697            decoder.debug_check_bounds::<Self>(offset);
18698            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18699                None => return Err(fidl::Error::NotNullable),
18700                Some(len) => len,
18701            };
18702            // Calling decoder.out_of_line_offset(0) is not allowed.
18703            if len == 0 {
18704                return Ok(());
18705            };
18706            depth.increment()?;
18707            let envelope_size = 8;
18708            let bytes_len = len * envelope_size;
18709            let offset = decoder.out_of_line_offset(bytes_len)?;
18710            // Decode the envelope for each type.
18711            let mut _next_ordinal_to_read = 0;
18712            let mut next_offset = offset;
18713            let end_offset = offset + bytes_len;
18714            _next_ordinal_to_read += 1;
18715            if next_offset >= end_offset {
18716                return Ok(());
18717            }
18718
18719            // Decode unknown envelopes for gaps in ordinals.
18720            while _next_ordinal_to_read < 1 {
18721                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18722                _next_ordinal_to_read += 1;
18723                next_offset += envelope_size;
18724            }
18725
18726            let next_out_of_line = decoder.next_out_of_line();
18727            let handles_before = decoder.remaining_handles();
18728            if let Some((inlined, num_bytes, num_handles)) =
18729                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18730            {
18731                let member_inline_size =
18732                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18733                if inlined != (member_inline_size <= 4) {
18734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18735                }
18736                let inner_offset;
18737                let mut inner_depth = depth.clone();
18738                if inlined {
18739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18740                    inner_offset = next_offset;
18741                } else {
18742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18743                    inner_depth.increment()?;
18744                }
18745                let val_ref = self.nbytes.get_or_insert_with(|| fidl::new_empty!(u16, D));
18746                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
18747                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18748                {
18749                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18750                }
18751                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18752                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18753                }
18754            }
18755
18756            next_offset += envelope_size;
18757            _next_ordinal_to_read += 1;
18758            if next_offset >= end_offset {
18759                return Ok(());
18760            }
18761
18762            // Decode unknown envelopes for gaps in ordinals.
18763            while _next_ordinal_to_read < 2 {
18764                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18765                _next_ordinal_to_read += 1;
18766                next_offset += envelope_size;
18767            }
18768
18769            let next_out_of_line = decoder.next_out_of_line();
18770            let handles_before = decoder.remaining_handles();
18771            if let Some((inlined, num_bytes, num_handles)) =
18772                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18773            {
18774                let member_inline_size =
18775                    <Lc3FrameDuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18776                if inlined != (member_inline_size <= 4) {
18777                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18778                }
18779                let inner_offset;
18780                let mut inner_depth = depth.clone();
18781                if inlined {
18782                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18783                    inner_offset = next_offset;
18784                } else {
18785                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18786                    inner_depth.increment()?;
18787                }
18788                let val_ref = self
18789                    .frame_duration
18790                    .get_or_insert_with(|| fidl::new_empty!(Lc3FrameDuration, D));
18791                fidl::decode!(Lc3FrameDuration, D, val_ref, decoder, inner_offset, inner_depth)?;
18792                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18793                {
18794                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18795                }
18796                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18797                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18798                }
18799            }
18800
18801            next_offset += envelope_size;
18802
18803            // Decode the remaining unknown envelopes.
18804            while next_offset < end_offset {
18805                _next_ordinal_to_read += 1;
18806                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18807                next_offset += envelope_size;
18808            }
18809
18810            Ok(())
18811        }
18812    }
18813
18814    impl LoopbackAudioCapturerConfiguration {
18815        #[inline(always)]
18816        fn max_ordinal_present(&self) -> u64 {
18817            0
18818        }
18819    }
18820
18821    impl fidl::encoding::ValueTypeMarker for LoopbackAudioCapturerConfiguration {
18822        type Borrowed<'a> = &'a Self;
18823        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18824            value
18825        }
18826    }
18827
18828    unsafe impl fidl::encoding::TypeMarker for LoopbackAudioCapturerConfiguration {
18829        type Owned = Self;
18830
18831        #[inline(always)]
18832        fn inline_align(_context: fidl::encoding::Context) -> usize {
18833            8
18834        }
18835
18836        #[inline(always)]
18837        fn inline_size(_context: fidl::encoding::Context) -> usize {
18838            16
18839        }
18840    }
18841
18842    unsafe impl<D: fidl::encoding::ResourceDialect>
18843        fidl::encoding::Encode<LoopbackAudioCapturerConfiguration, D>
18844        for &LoopbackAudioCapturerConfiguration
18845    {
18846        unsafe fn encode(
18847            self,
18848            encoder: &mut fidl::encoding::Encoder<'_, D>,
18849            offset: usize,
18850            mut depth: fidl::encoding::Depth,
18851        ) -> fidl::Result<()> {
18852            encoder.debug_check_bounds::<LoopbackAudioCapturerConfiguration>(offset);
18853            // Vector header
18854            let max_ordinal: u64 = self.max_ordinal_present();
18855            encoder.write_num(max_ordinal, offset);
18856            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18857            // Calling encoder.out_of_line_offset(0) is not allowed.
18858            if max_ordinal == 0 {
18859                return Ok(());
18860            }
18861            depth.increment()?;
18862            let envelope_size = 8;
18863            let bytes_len = max_ordinal as usize * envelope_size;
18864            #[allow(unused_variables)]
18865            let offset = encoder.out_of_line_offset(bytes_len);
18866            let mut _prev_end_offset: usize = 0;
18867
18868            Ok(())
18869        }
18870    }
18871
18872    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
18873        for LoopbackAudioCapturerConfiguration
18874    {
18875        #[inline(always)]
18876        fn new_empty() -> Self {
18877            Self::default()
18878        }
18879
18880        unsafe fn decode(
18881            &mut self,
18882            decoder: &mut fidl::encoding::Decoder<'_, D>,
18883            offset: usize,
18884            mut depth: fidl::encoding::Depth,
18885        ) -> fidl::Result<()> {
18886            decoder.debug_check_bounds::<Self>(offset);
18887            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18888                None => return Err(fidl::Error::NotNullable),
18889                Some(len) => len,
18890            };
18891            // Calling decoder.out_of_line_offset(0) is not allowed.
18892            if len == 0 {
18893                return Ok(());
18894            };
18895            depth.increment()?;
18896            let envelope_size = 8;
18897            let bytes_len = len * envelope_size;
18898            let offset = decoder.out_of_line_offset(bytes_len)?;
18899            // Decode the envelope for each type.
18900            let mut _next_ordinal_to_read = 0;
18901            let mut next_offset = offset;
18902            let end_offset = offset + bytes_len;
18903
18904            // Decode the remaining unknown envelopes.
18905            while next_offset < end_offset {
18906                _next_ordinal_to_read += 1;
18907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18908                next_offset += envelope_size;
18909            }
18910
18911            Ok(())
18912        }
18913    }
18914
18915    impl MSbcEncoderSettings {
18916        #[inline(always)]
18917        fn max_ordinal_present(&self) -> u64 {
18918            0
18919        }
18920    }
18921
18922    impl fidl::encoding::ValueTypeMarker for MSbcEncoderSettings {
18923        type Borrowed<'a> = &'a Self;
18924        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18925            value
18926        }
18927    }
18928
18929    unsafe impl fidl::encoding::TypeMarker for MSbcEncoderSettings {
18930        type Owned = Self;
18931
18932        #[inline(always)]
18933        fn inline_align(_context: fidl::encoding::Context) -> usize {
18934            8
18935        }
18936
18937        #[inline(always)]
18938        fn inline_size(_context: fidl::encoding::Context) -> usize {
18939            16
18940        }
18941    }
18942
18943    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MSbcEncoderSettings, D>
18944        for &MSbcEncoderSettings
18945    {
18946        unsafe fn encode(
18947            self,
18948            encoder: &mut fidl::encoding::Encoder<'_, D>,
18949            offset: usize,
18950            mut depth: fidl::encoding::Depth,
18951        ) -> fidl::Result<()> {
18952            encoder.debug_check_bounds::<MSbcEncoderSettings>(offset);
18953            // Vector header
18954            let max_ordinal: u64 = self.max_ordinal_present();
18955            encoder.write_num(max_ordinal, offset);
18956            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18957            // Calling encoder.out_of_line_offset(0) is not allowed.
18958            if max_ordinal == 0 {
18959                return Ok(());
18960            }
18961            depth.increment()?;
18962            let envelope_size = 8;
18963            let bytes_len = max_ordinal as usize * envelope_size;
18964            #[allow(unused_variables)]
18965            let offset = encoder.out_of_line_offset(bytes_len);
18966            let mut _prev_end_offset: usize = 0;
18967
18968            Ok(())
18969        }
18970    }
18971
18972    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MSbcEncoderSettings {
18973        #[inline(always)]
18974        fn new_empty() -> Self {
18975            Self::default()
18976        }
18977
18978        unsafe fn decode(
18979            &mut self,
18980            decoder: &mut fidl::encoding::Decoder<'_, D>,
18981            offset: usize,
18982            mut depth: fidl::encoding::Depth,
18983        ) -> fidl::Result<()> {
18984            decoder.debug_check_bounds::<Self>(offset);
18985            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18986                None => return Err(fidl::Error::NotNullable),
18987                Some(len) => len,
18988            };
18989            // Calling decoder.out_of_line_offset(0) is not allowed.
18990            if len == 0 {
18991                return Ok(());
18992            };
18993            depth.increment()?;
18994            let envelope_size = 8;
18995            let bytes_len = len * envelope_size;
18996            let offset = decoder.out_of_line_offset(bytes_len)?;
18997            // Decode the envelope for each type.
18998            let mut _next_ordinal_to_read = 0;
18999            let mut next_offset = offset;
19000            let end_offset = offset + bytes_len;
19001
19002            // Decode the remaining unknown envelopes.
19003            while next_offset < end_offset {
19004                _next_ordinal_to_read += 1;
19005                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19006                next_offset += envelope_size;
19007            }
19008
19009            Ok(())
19010        }
19011    }
19012
19013    impl Packet {
19014        #[inline(always)]
19015        fn max_ordinal_present(&self) -> u64 {
19016            if let Some(_) = self.key_frame {
19017                return 9;
19018            }
19019            if let Some(_) = self.known_end_access_unit {
19020                return 8;
19021            }
19022            if let Some(_) = self.start_access_unit {
19023                return 7;
19024            }
19025            if let Some(_) = self.timestamp_ish {
19026                return 6;
19027            }
19028            if let Some(_) = self.valid_length_bytes {
19029                return 5;
19030            }
19031            if let Some(_) = self.start_offset {
19032                return 4;
19033            }
19034            if let Some(_) = self.stream_lifetime_ordinal {
19035                return 3;
19036            }
19037            if let Some(_) = self.buffer_index {
19038                return 2;
19039            }
19040            if let Some(_) = self.header {
19041                return 1;
19042            }
19043            0
19044        }
19045    }
19046
19047    impl fidl::encoding::ValueTypeMarker for Packet {
19048        type Borrowed<'a> = &'a Self;
19049        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19050            value
19051        }
19052    }
19053
19054    unsafe impl fidl::encoding::TypeMarker for Packet {
19055        type Owned = Self;
19056
19057        #[inline(always)]
19058        fn inline_align(_context: fidl::encoding::Context) -> usize {
19059            8
19060        }
19061
19062        #[inline(always)]
19063        fn inline_size(_context: fidl::encoding::Context) -> usize {
19064            16
19065        }
19066    }
19067
19068    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Packet, D> for &Packet {
19069        unsafe fn encode(
19070            self,
19071            encoder: &mut fidl::encoding::Encoder<'_, D>,
19072            offset: usize,
19073            mut depth: fidl::encoding::Depth,
19074        ) -> fidl::Result<()> {
19075            encoder.debug_check_bounds::<Packet>(offset);
19076            // Vector header
19077            let max_ordinal: u64 = self.max_ordinal_present();
19078            encoder.write_num(max_ordinal, offset);
19079            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19080            // Calling encoder.out_of_line_offset(0) is not allowed.
19081            if max_ordinal == 0 {
19082                return Ok(());
19083            }
19084            depth.increment()?;
19085            let envelope_size = 8;
19086            let bytes_len = max_ordinal as usize * envelope_size;
19087            #[allow(unused_variables)]
19088            let offset = encoder.out_of_line_offset(bytes_len);
19089            let mut _prev_end_offset: usize = 0;
19090            if 1 > max_ordinal {
19091                return Ok(());
19092            }
19093
19094            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19095            // are envelope_size bytes.
19096            let cur_offset: usize = (1 - 1) * envelope_size;
19097
19098            // Zero reserved fields.
19099            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19100
19101            // Safety:
19102            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19103            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19104            //   envelope_size bytes, there is always sufficient room.
19105            fidl::encoding::encode_in_envelope_optional::<PacketHeader, D>(
19106                self.header.as_ref().map(<PacketHeader as fidl::encoding::ValueTypeMarker>::borrow),
19107                encoder,
19108                offset + cur_offset,
19109                depth,
19110            )?;
19111
19112            _prev_end_offset = cur_offset + envelope_size;
19113            if 2 > max_ordinal {
19114                return Ok(());
19115            }
19116
19117            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19118            // are envelope_size bytes.
19119            let cur_offset: usize = (2 - 1) * envelope_size;
19120
19121            // Zero reserved fields.
19122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19123
19124            // Safety:
19125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19127            //   envelope_size bytes, there is always sufficient room.
19128            fidl::encoding::encode_in_envelope_optional::<u32, D>(
19129                self.buffer_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19130                encoder,
19131                offset + cur_offset,
19132                depth,
19133            )?;
19134
19135            _prev_end_offset = cur_offset + envelope_size;
19136            if 3 > max_ordinal {
19137                return Ok(());
19138            }
19139
19140            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19141            // are envelope_size bytes.
19142            let cur_offset: usize = (3 - 1) * envelope_size;
19143
19144            // Zero reserved fields.
19145            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19146
19147            // Safety:
19148            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19149            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19150            //   envelope_size bytes, there is always sufficient room.
19151            fidl::encoding::encode_in_envelope_optional::<u64, D>(
19152                self.stream_lifetime_ordinal
19153                    .as_ref()
19154                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19155                encoder,
19156                offset + cur_offset,
19157                depth,
19158            )?;
19159
19160            _prev_end_offset = cur_offset + envelope_size;
19161            if 4 > max_ordinal {
19162                return Ok(());
19163            }
19164
19165            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19166            // are envelope_size bytes.
19167            let cur_offset: usize = (4 - 1) * envelope_size;
19168
19169            // Zero reserved fields.
19170            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19171
19172            // Safety:
19173            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19174            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19175            //   envelope_size bytes, there is always sufficient room.
19176            fidl::encoding::encode_in_envelope_optional::<u32, D>(
19177                self.start_offset.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19178                encoder,
19179                offset + cur_offset,
19180                depth,
19181            )?;
19182
19183            _prev_end_offset = cur_offset + envelope_size;
19184            if 5 > max_ordinal {
19185                return Ok(());
19186            }
19187
19188            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19189            // are envelope_size bytes.
19190            let cur_offset: usize = (5 - 1) * envelope_size;
19191
19192            // Zero reserved fields.
19193            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19194
19195            // Safety:
19196            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19197            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19198            //   envelope_size bytes, there is always sufficient room.
19199            fidl::encoding::encode_in_envelope_optional::<u32, D>(
19200                self.valid_length_bytes
19201                    .as_ref()
19202                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19203                encoder,
19204                offset + cur_offset,
19205                depth,
19206            )?;
19207
19208            _prev_end_offset = cur_offset + envelope_size;
19209            if 6 > max_ordinal {
19210                return Ok(());
19211            }
19212
19213            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19214            // are envelope_size bytes.
19215            let cur_offset: usize = (6 - 1) * envelope_size;
19216
19217            // Zero reserved fields.
19218            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19219
19220            // Safety:
19221            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19222            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19223            //   envelope_size bytes, there is always sufficient room.
19224            fidl::encoding::encode_in_envelope_optional::<u64, D>(
19225                self.timestamp_ish.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19226                encoder,
19227                offset + cur_offset,
19228                depth,
19229            )?;
19230
19231            _prev_end_offset = cur_offset + envelope_size;
19232            if 7 > max_ordinal {
19233                return Ok(());
19234            }
19235
19236            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19237            // are envelope_size bytes.
19238            let cur_offset: usize = (7 - 1) * envelope_size;
19239
19240            // Zero reserved fields.
19241            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19242
19243            // Safety:
19244            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19245            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19246            //   envelope_size bytes, there is always sufficient room.
19247            fidl::encoding::encode_in_envelope_optional::<bool, D>(
19248                self.start_access_unit
19249                    .as_ref()
19250                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19251                encoder,
19252                offset + cur_offset,
19253                depth,
19254            )?;
19255
19256            _prev_end_offset = cur_offset + envelope_size;
19257            if 8 > max_ordinal {
19258                return Ok(());
19259            }
19260
19261            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19262            // are envelope_size bytes.
19263            let cur_offset: usize = (8 - 1) * envelope_size;
19264
19265            // Zero reserved fields.
19266            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19267
19268            // Safety:
19269            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19270            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19271            //   envelope_size bytes, there is always sufficient room.
19272            fidl::encoding::encode_in_envelope_optional::<bool, D>(
19273                self.known_end_access_unit
19274                    .as_ref()
19275                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19276                encoder,
19277                offset + cur_offset,
19278                depth,
19279            )?;
19280
19281            _prev_end_offset = cur_offset + envelope_size;
19282            if 9 > max_ordinal {
19283                return Ok(());
19284            }
19285
19286            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19287            // are envelope_size bytes.
19288            let cur_offset: usize = (9 - 1) * envelope_size;
19289
19290            // Zero reserved fields.
19291            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19292
19293            // Safety:
19294            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19295            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19296            //   envelope_size bytes, there is always sufficient room.
19297            fidl::encoding::encode_in_envelope_optional::<bool, D>(
19298                self.key_frame.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
19299                encoder,
19300                offset + cur_offset,
19301                depth,
19302            )?;
19303
19304            _prev_end_offset = cur_offset + envelope_size;
19305
19306            Ok(())
19307        }
19308    }
19309
19310    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Packet {
19311        #[inline(always)]
19312        fn new_empty() -> Self {
19313            Self::default()
19314        }
19315
19316        unsafe fn decode(
19317            &mut self,
19318            decoder: &mut fidl::encoding::Decoder<'_, D>,
19319            offset: usize,
19320            mut depth: fidl::encoding::Depth,
19321        ) -> fidl::Result<()> {
19322            decoder.debug_check_bounds::<Self>(offset);
19323            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19324                None => return Err(fidl::Error::NotNullable),
19325                Some(len) => len,
19326            };
19327            // Calling decoder.out_of_line_offset(0) is not allowed.
19328            if len == 0 {
19329                return Ok(());
19330            };
19331            depth.increment()?;
19332            let envelope_size = 8;
19333            let bytes_len = len * envelope_size;
19334            let offset = decoder.out_of_line_offset(bytes_len)?;
19335            // Decode the envelope for each type.
19336            let mut _next_ordinal_to_read = 0;
19337            let mut next_offset = offset;
19338            let end_offset = offset + bytes_len;
19339            _next_ordinal_to_read += 1;
19340            if next_offset >= end_offset {
19341                return Ok(());
19342            }
19343
19344            // Decode unknown envelopes for gaps in ordinals.
19345            while _next_ordinal_to_read < 1 {
19346                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19347                _next_ordinal_to_read += 1;
19348                next_offset += envelope_size;
19349            }
19350
19351            let next_out_of_line = decoder.next_out_of_line();
19352            let handles_before = decoder.remaining_handles();
19353            if let Some((inlined, num_bytes, num_handles)) =
19354                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19355            {
19356                let member_inline_size =
19357                    <PacketHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19358                if inlined != (member_inline_size <= 4) {
19359                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19360                }
19361                let inner_offset;
19362                let mut inner_depth = depth.clone();
19363                if inlined {
19364                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19365                    inner_offset = next_offset;
19366                } else {
19367                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19368                    inner_depth.increment()?;
19369                }
19370                let val_ref = self.header.get_or_insert_with(|| fidl::new_empty!(PacketHeader, D));
19371                fidl::decode!(PacketHeader, D, val_ref, decoder, inner_offset, inner_depth)?;
19372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19373                {
19374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19375                }
19376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19378                }
19379            }
19380
19381            next_offset += envelope_size;
19382            _next_ordinal_to_read += 1;
19383            if next_offset >= end_offset {
19384                return Ok(());
19385            }
19386
19387            // Decode unknown envelopes for gaps in ordinals.
19388            while _next_ordinal_to_read < 2 {
19389                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19390                _next_ordinal_to_read += 1;
19391                next_offset += envelope_size;
19392            }
19393
19394            let next_out_of_line = decoder.next_out_of_line();
19395            let handles_before = decoder.remaining_handles();
19396            if let Some((inlined, num_bytes, num_handles)) =
19397                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19398            {
19399                let member_inline_size =
19400                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19401                if inlined != (member_inline_size <= 4) {
19402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19403                }
19404                let inner_offset;
19405                let mut inner_depth = depth.clone();
19406                if inlined {
19407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19408                    inner_offset = next_offset;
19409                } else {
19410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19411                    inner_depth.increment()?;
19412                }
19413                let val_ref = self.buffer_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19414                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19415                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19416                {
19417                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19418                }
19419                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19420                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19421                }
19422            }
19423
19424            next_offset += envelope_size;
19425            _next_ordinal_to_read += 1;
19426            if next_offset >= end_offset {
19427                return Ok(());
19428            }
19429
19430            // Decode unknown envelopes for gaps in ordinals.
19431            while _next_ordinal_to_read < 3 {
19432                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19433                _next_ordinal_to_read += 1;
19434                next_offset += envelope_size;
19435            }
19436
19437            let next_out_of_line = decoder.next_out_of_line();
19438            let handles_before = decoder.remaining_handles();
19439            if let Some((inlined, num_bytes, num_handles)) =
19440                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19441            {
19442                let member_inline_size =
19443                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19444                if inlined != (member_inline_size <= 4) {
19445                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19446                }
19447                let inner_offset;
19448                let mut inner_depth = depth.clone();
19449                if inlined {
19450                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19451                    inner_offset = next_offset;
19452                } else {
19453                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19454                    inner_depth.increment()?;
19455                }
19456                let val_ref =
19457                    self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19458                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19459                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19460                {
19461                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19462                }
19463                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19464                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19465                }
19466            }
19467
19468            next_offset += envelope_size;
19469            _next_ordinal_to_read += 1;
19470            if next_offset >= end_offset {
19471                return Ok(());
19472            }
19473
19474            // Decode unknown envelopes for gaps in ordinals.
19475            while _next_ordinal_to_read < 4 {
19476                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19477                _next_ordinal_to_read += 1;
19478                next_offset += envelope_size;
19479            }
19480
19481            let next_out_of_line = decoder.next_out_of_line();
19482            let handles_before = decoder.remaining_handles();
19483            if let Some((inlined, num_bytes, num_handles)) =
19484                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19485            {
19486                let member_inline_size =
19487                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19488                if inlined != (member_inline_size <= 4) {
19489                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19490                }
19491                let inner_offset;
19492                let mut inner_depth = depth.clone();
19493                if inlined {
19494                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19495                    inner_offset = next_offset;
19496                } else {
19497                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19498                    inner_depth.increment()?;
19499                }
19500                let val_ref = self.start_offset.get_or_insert_with(|| fidl::new_empty!(u32, D));
19501                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19502                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19503                {
19504                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19505                }
19506                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19507                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19508                }
19509            }
19510
19511            next_offset += envelope_size;
19512            _next_ordinal_to_read += 1;
19513            if next_offset >= end_offset {
19514                return Ok(());
19515            }
19516
19517            // Decode unknown envelopes for gaps in ordinals.
19518            while _next_ordinal_to_read < 5 {
19519                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19520                _next_ordinal_to_read += 1;
19521                next_offset += envelope_size;
19522            }
19523
19524            let next_out_of_line = decoder.next_out_of_line();
19525            let handles_before = decoder.remaining_handles();
19526            if let Some((inlined, num_bytes, num_handles)) =
19527                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19528            {
19529                let member_inline_size =
19530                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19531                if inlined != (member_inline_size <= 4) {
19532                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19533                }
19534                let inner_offset;
19535                let mut inner_depth = depth.clone();
19536                if inlined {
19537                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19538                    inner_offset = next_offset;
19539                } else {
19540                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19541                    inner_depth.increment()?;
19542                }
19543                let val_ref =
19544                    self.valid_length_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
19545                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19546                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19547                {
19548                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19549                }
19550                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19551                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19552                }
19553            }
19554
19555            next_offset += envelope_size;
19556            _next_ordinal_to_read += 1;
19557            if next_offset >= end_offset {
19558                return Ok(());
19559            }
19560
19561            // Decode unknown envelopes for gaps in ordinals.
19562            while _next_ordinal_to_read < 6 {
19563                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19564                _next_ordinal_to_read += 1;
19565                next_offset += envelope_size;
19566            }
19567
19568            let next_out_of_line = decoder.next_out_of_line();
19569            let handles_before = decoder.remaining_handles();
19570            if let Some((inlined, num_bytes, num_handles)) =
19571                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19572            {
19573                let member_inline_size =
19574                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19575                if inlined != (member_inline_size <= 4) {
19576                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19577                }
19578                let inner_offset;
19579                let mut inner_depth = depth.clone();
19580                if inlined {
19581                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19582                    inner_offset = next_offset;
19583                } else {
19584                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19585                    inner_depth.increment()?;
19586                }
19587                let val_ref = self.timestamp_ish.get_or_insert_with(|| fidl::new_empty!(u64, D));
19588                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19589                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19590                {
19591                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19592                }
19593                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19594                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19595                }
19596            }
19597
19598            next_offset += envelope_size;
19599            _next_ordinal_to_read += 1;
19600            if next_offset >= end_offset {
19601                return Ok(());
19602            }
19603
19604            // Decode unknown envelopes for gaps in ordinals.
19605            while _next_ordinal_to_read < 7 {
19606                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19607                _next_ordinal_to_read += 1;
19608                next_offset += envelope_size;
19609            }
19610
19611            let next_out_of_line = decoder.next_out_of_line();
19612            let handles_before = decoder.remaining_handles();
19613            if let Some((inlined, num_bytes, num_handles)) =
19614                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19615            {
19616                let member_inline_size =
19617                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19618                if inlined != (member_inline_size <= 4) {
19619                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19620                }
19621                let inner_offset;
19622                let mut inner_depth = depth.clone();
19623                if inlined {
19624                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19625                    inner_offset = next_offset;
19626                } else {
19627                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19628                    inner_depth.increment()?;
19629                }
19630                let val_ref =
19631                    self.start_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19632                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19633                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19634                {
19635                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19636                }
19637                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19638                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19639                }
19640            }
19641
19642            next_offset += envelope_size;
19643            _next_ordinal_to_read += 1;
19644            if next_offset >= end_offset {
19645                return Ok(());
19646            }
19647
19648            // Decode unknown envelopes for gaps in ordinals.
19649            while _next_ordinal_to_read < 8 {
19650                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19651                _next_ordinal_to_read += 1;
19652                next_offset += envelope_size;
19653            }
19654
19655            let next_out_of_line = decoder.next_out_of_line();
19656            let handles_before = decoder.remaining_handles();
19657            if let Some((inlined, num_bytes, num_handles)) =
19658                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19659            {
19660                let member_inline_size =
19661                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19662                if inlined != (member_inline_size <= 4) {
19663                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19664                }
19665                let inner_offset;
19666                let mut inner_depth = depth.clone();
19667                if inlined {
19668                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19669                    inner_offset = next_offset;
19670                } else {
19671                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19672                    inner_depth.increment()?;
19673                }
19674                let val_ref =
19675                    self.known_end_access_unit.get_or_insert_with(|| fidl::new_empty!(bool, D));
19676                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19677                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19678                {
19679                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19680                }
19681                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19682                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19683                }
19684            }
19685
19686            next_offset += envelope_size;
19687            _next_ordinal_to_read += 1;
19688            if next_offset >= end_offset {
19689                return Ok(());
19690            }
19691
19692            // Decode unknown envelopes for gaps in ordinals.
19693            while _next_ordinal_to_read < 9 {
19694                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19695                _next_ordinal_to_read += 1;
19696                next_offset += envelope_size;
19697            }
19698
19699            let next_out_of_line = decoder.next_out_of_line();
19700            let handles_before = decoder.remaining_handles();
19701            if let Some((inlined, num_bytes, num_handles)) =
19702                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19703            {
19704                let member_inline_size =
19705                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19706                if inlined != (member_inline_size <= 4) {
19707                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19708                }
19709                let inner_offset;
19710                let mut inner_depth = depth.clone();
19711                if inlined {
19712                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19713                    inner_offset = next_offset;
19714                } else {
19715                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19716                    inner_depth.increment()?;
19717                }
19718                let val_ref = self.key_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
19719                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
19720                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19721                {
19722                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19723                }
19724                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19725                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19726                }
19727            }
19728
19729            next_offset += envelope_size;
19730
19731            // Decode the remaining unknown envelopes.
19732            while next_offset < end_offset {
19733                _next_ordinal_to_read += 1;
19734                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19735                next_offset += envelope_size;
19736            }
19737
19738            Ok(())
19739        }
19740    }
19741
19742    impl PacketHeader {
19743        #[inline(always)]
19744        fn max_ordinal_present(&self) -> u64 {
19745            if let Some(_) = self.packet_index {
19746                return 2;
19747            }
19748            if let Some(_) = self.buffer_lifetime_ordinal {
19749                return 1;
19750            }
19751            0
19752        }
19753    }
19754
19755    impl fidl::encoding::ValueTypeMarker for PacketHeader {
19756        type Borrowed<'a> = &'a Self;
19757        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19758            value
19759        }
19760    }
19761
19762    unsafe impl fidl::encoding::TypeMarker for PacketHeader {
19763        type Owned = Self;
19764
19765        #[inline(always)]
19766        fn inline_align(_context: fidl::encoding::Context) -> usize {
19767            8
19768        }
19769
19770        #[inline(always)]
19771        fn inline_size(_context: fidl::encoding::Context) -> usize {
19772            16
19773        }
19774    }
19775
19776    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PacketHeader, D>
19777        for &PacketHeader
19778    {
19779        unsafe fn encode(
19780            self,
19781            encoder: &mut fidl::encoding::Encoder<'_, D>,
19782            offset: usize,
19783            mut depth: fidl::encoding::Depth,
19784        ) -> fidl::Result<()> {
19785            encoder.debug_check_bounds::<PacketHeader>(offset);
19786            // Vector header
19787            let max_ordinal: u64 = self.max_ordinal_present();
19788            encoder.write_num(max_ordinal, offset);
19789            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19790            // Calling encoder.out_of_line_offset(0) is not allowed.
19791            if max_ordinal == 0 {
19792                return Ok(());
19793            }
19794            depth.increment()?;
19795            let envelope_size = 8;
19796            let bytes_len = max_ordinal as usize * envelope_size;
19797            #[allow(unused_variables)]
19798            let offset = encoder.out_of_line_offset(bytes_len);
19799            let mut _prev_end_offset: usize = 0;
19800            if 1 > max_ordinal {
19801                return Ok(());
19802            }
19803
19804            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19805            // are envelope_size bytes.
19806            let cur_offset: usize = (1 - 1) * envelope_size;
19807
19808            // Zero reserved fields.
19809            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19810
19811            // Safety:
19812            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19813            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19814            //   envelope_size bytes, there is always sufficient room.
19815            fidl::encoding::encode_in_envelope_optional::<u64, D>(
19816                self.buffer_lifetime_ordinal
19817                    .as_ref()
19818                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
19819                encoder,
19820                offset + cur_offset,
19821                depth,
19822            )?;
19823
19824            _prev_end_offset = cur_offset + envelope_size;
19825            if 2 > max_ordinal {
19826                return Ok(());
19827            }
19828
19829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19830            // are envelope_size bytes.
19831            let cur_offset: usize = (2 - 1) * envelope_size;
19832
19833            // Zero reserved fields.
19834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19835
19836            // Safety:
19837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19839            //   envelope_size bytes, there is always sufficient room.
19840            fidl::encoding::encode_in_envelope_optional::<u32, D>(
19841                self.packet_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
19842                encoder,
19843                offset + cur_offset,
19844                depth,
19845            )?;
19846
19847            _prev_end_offset = cur_offset + envelope_size;
19848
19849            Ok(())
19850        }
19851    }
19852
19853    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PacketHeader {
19854        #[inline(always)]
19855        fn new_empty() -> Self {
19856            Self::default()
19857        }
19858
19859        unsafe fn decode(
19860            &mut self,
19861            decoder: &mut fidl::encoding::Decoder<'_, D>,
19862            offset: usize,
19863            mut depth: fidl::encoding::Depth,
19864        ) -> fidl::Result<()> {
19865            decoder.debug_check_bounds::<Self>(offset);
19866            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19867                None => return Err(fidl::Error::NotNullable),
19868                Some(len) => len,
19869            };
19870            // Calling decoder.out_of_line_offset(0) is not allowed.
19871            if len == 0 {
19872                return Ok(());
19873            };
19874            depth.increment()?;
19875            let envelope_size = 8;
19876            let bytes_len = len * envelope_size;
19877            let offset = decoder.out_of_line_offset(bytes_len)?;
19878            // Decode the envelope for each type.
19879            let mut _next_ordinal_to_read = 0;
19880            let mut next_offset = offset;
19881            let end_offset = offset + bytes_len;
19882            _next_ordinal_to_read += 1;
19883            if next_offset >= end_offset {
19884                return Ok(());
19885            }
19886
19887            // Decode unknown envelopes for gaps in ordinals.
19888            while _next_ordinal_to_read < 1 {
19889                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19890                _next_ordinal_to_read += 1;
19891                next_offset += envelope_size;
19892            }
19893
19894            let next_out_of_line = decoder.next_out_of_line();
19895            let handles_before = decoder.remaining_handles();
19896            if let Some((inlined, num_bytes, num_handles)) =
19897                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19898            {
19899                let member_inline_size =
19900                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19901                if inlined != (member_inline_size <= 4) {
19902                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19903                }
19904                let inner_offset;
19905                let mut inner_depth = depth.clone();
19906                if inlined {
19907                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19908                    inner_offset = next_offset;
19909                } else {
19910                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19911                    inner_depth.increment()?;
19912                }
19913                let val_ref =
19914                    self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
19915                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
19916                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19917                {
19918                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19919                }
19920                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19921                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19922                }
19923            }
19924
19925            next_offset += envelope_size;
19926            _next_ordinal_to_read += 1;
19927            if next_offset >= end_offset {
19928                return Ok(());
19929            }
19930
19931            // Decode unknown envelopes for gaps in ordinals.
19932            while _next_ordinal_to_read < 2 {
19933                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19934                _next_ordinal_to_read += 1;
19935                next_offset += envelope_size;
19936            }
19937
19938            let next_out_of_line = decoder.next_out_of_line();
19939            let handles_before = decoder.remaining_handles();
19940            if let Some((inlined, num_bytes, num_handles)) =
19941                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19942            {
19943                let member_inline_size =
19944                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19945                if inlined != (member_inline_size <= 4) {
19946                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19947                }
19948                let inner_offset;
19949                let mut inner_depth = depth.clone();
19950                if inlined {
19951                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19952                    inner_offset = next_offset;
19953                } else {
19954                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19955                    inner_depth.increment()?;
19956                }
19957                let val_ref = self.packet_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
19958                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
19959                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19960                {
19961                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19962                }
19963                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19964                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19965                }
19966            }
19967
19968            next_offset += envelope_size;
19969
19970            // Decode the remaining unknown envelopes.
19971            while next_offset < end_offset {
19972                _next_ordinal_to_read += 1;
19973                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19974                next_offset += envelope_size;
19975            }
19976
19977            Ok(())
19978        }
19979    }
19980
19981    impl StreamBufferConstraints {
19982        #[inline(always)]
19983        fn max_ordinal_present(&self) -> u64 {
19984            if let Some(_) = self.is_physically_contiguous_required {
19985                return 13;
19986            }
19987            if let Some(_) = self.single_buffer_mode_allowed {
19988                return 12;
19989            }
19990            if let Some(_) = self.packet_count_for_client_max {
19991                return 11;
19992            }
19993            if let Some(_) = self.packet_count_for_client_min {
19994                return 10;
19995            }
19996            if let Some(_) = self.packet_count_for_server_max {
19997                return 9;
19998            }
19999            if let Some(_) = self.packet_count_for_server_recommended_max {
20000                return 8;
20001            }
20002            if let Some(_) = self.packet_count_for_server_recommended {
20003                return 7;
20004            }
20005            if let Some(_) = self.packet_count_for_server_min {
20006                return 6;
20007            }
20008            if let Some(_) = self.per_packet_buffer_bytes_max {
20009                return 5;
20010            }
20011            if let Some(_) = self.per_packet_buffer_bytes_recommended {
20012                return 4;
20013            }
20014            if let Some(_) = self.per_packet_buffer_bytes_min {
20015                return 3;
20016            }
20017            if let Some(_) = self.default_settings {
20018                return 2;
20019            }
20020            if let Some(_) = self.buffer_constraints_version_ordinal {
20021                return 1;
20022            }
20023            0
20024        }
20025    }
20026
20027    impl fidl::encoding::ValueTypeMarker for StreamBufferConstraints {
20028        type Borrowed<'a> = &'a Self;
20029        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20030            value
20031        }
20032    }
20033
20034    unsafe impl fidl::encoding::TypeMarker for StreamBufferConstraints {
20035        type Owned = Self;
20036
20037        #[inline(always)]
20038        fn inline_align(_context: fidl::encoding::Context) -> usize {
20039            8
20040        }
20041
20042        #[inline(always)]
20043        fn inline_size(_context: fidl::encoding::Context) -> usize {
20044            16
20045        }
20046    }
20047
20048    unsafe impl<D: fidl::encoding::ResourceDialect>
20049        fidl::encoding::Encode<StreamBufferConstraints, D> for &StreamBufferConstraints
20050    {
20051        unsafe fn encode(
20052            self,
20053            encoder: &mut fidl::encoding::Encoder<'_, D>,
20054            offset: usize,
20055            mut depth: fidl::encoding::Depth,
20056        ) -> fidl::Result<()> {
20057            encoder.debug_check_bounds::<StreamBufferConstraints>(offset);
20058            // Vector header
20059            let max_ordinal: u64 = self.max_ordinal_present();
20060            encoder.write_num(max_ordinal, offset);
20061            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20062            // Calling encoder.out_of_line_offset(0) is not allowed.
20063            if max_ordinal == 0 {
20064                return Ok(());
20065            }
20066            depth.increment()?;
20067            let envelope_size = 8;
20068            let bytes_len = max_ordinal as usize * envelope_size;
20069            #[allow(unused_variables)]
20070            let offset = encoder.out_of_line_offset(bytes_len);
20071            let mut _prev_end_offset: usize = 0;
20072            if 1 > max_ordinal {
20073                return Ok(());
20074            }
20075
20076            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20077            // are envelope_size bytes.
20078            let cur_offset: usize = (1 - 1) * envelope_size;
20079
20080            // Zero reserved fields.
20081            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20082
20083            // Safety:
20084            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20085            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20086            //   envelope_size bytes, there is always sufficient room.
20087            fidl::encoding::encode_in_envelope_optional::<u64, D>(
20088                self.buffer_constraints_version_ordinal
20089                    .as_ref()
20090                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
20091                encoder,
20092                offset + cur_offset,
20093                depth,
20094            )?;
20095
20096            _prev_end_offset = cur_offset + envelope_size;
20097            if 2 > max_ordinal {
20098                return Ok(());
20099            }
20100
20101            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20102            // are envelope_size bytes.
20103            let cur_offset: usize = (2 - 1) * envelope_size;
20104
20105            // Zero reserved fields.
20106            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20107
20108            // Safety:
20109            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20110            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20111            //   envelope_size bytes, there is always sufficient room.
20112            fidl::encoding::encode_in_envelope_optional::<StreamBufferSettings, D>(
20113                self.default_settings
20114                    .as_ref()
20115                    .map(<StreamBufferSettings as fidl::encoding::ValueTypeMarker>::borrow),
20116                encoder,
20117                offset + cur_offset,
20118                depth,
20119            )?;
20120
20121            _prev_end_offset = cur_offset + envelope_size;
20122            if 3 > max_ordinal {
20123                return Ok(());
20124            }
20125
20126            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20127            // are envelope_size bytes.
20128            let cur_offset: usize = (3 - 1) * envelope_size;
20129
20130            // Zero reserved fields.
20131            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20132
20133            // Safety:
20134            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20135            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20136            //   envelope_size bytes, there is always sufficient room.
20137            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20138                self.per_packet_buffer_bytes_min
20139                    .as_ref()
20140                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20141                encoder,
20142                offset + cur_offset,
20143                depth,
20144            )?;
20145
20146            _prev_end_offset = cur_offset + envelope_size;
20147            if 4 > max_ordinal {
20148                return Ok(());
20149            }
20150
20151            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20152            // are envelope_size bytes.
20153            let cur_offset: usize = (4 - 1) * envelope_size;
20154
20155            // Zero reserved fields.
20156            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20157
20158            // Safety:
20159            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20160            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20161            //   envelope_size bytes, there is always sufficient room.
20162            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20163                self.per_packet_buffer_bytes_recommended
20164                    .as_ref()
20165                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20166                encoder,
20167                offset + cur_offset,
20168                depth,
20169            )?;
20170
20171            _prev_end_offset = cur_offset + envelope_size;
20172            if 5 > max_ordinal {
20173                return Ok(());
20174            }
20175
20176            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20177            // are envelope_size bytes.
20178            let cur_offset: usize = (5 - 1) * envelope_size;
20179
20180            // Zero reserved fields.
20181            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20182
20183            // Safety:
20184            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20185            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20186            //   envelope_size bytes, there is always sufficient room.
20187            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20188                self.per_packet_buffer_bytes_max
20189                    .as_ref()
20190                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20191                encoder,
20192                offset + cur_offset,
20193                depth,
20194            )?;
20195
20196            _prev_end_offset = cur_offset + envelope_size;
20197            if 6 > max_ordinal {
20198                return Ok(());
20199            }
20200
20201            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20202            // are envelope_size bytes.
20203            let cur_offset: usize = (6 - 1) * envelope_size;
20204
20205            // Zero reserved fields.
20206            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20207
20208            // Safety:
20209            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20210            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20211            //   envelope_size bytes, there is always sufficient room.
20212            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20213                self.packet_count_for_server_min
20214                    .as_ref()
20215                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20216                encoder,
20217                offset + cur_offset,
20218                depth,
20219            )?;
20220
20221            _prev_end_offset = cur_offset + envelope_size;
20222            if 7 > max_ordinal {
20223                return Ok(());
20224            }
20225
20226            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20227            // are envelope_size bytes.
20228            let cur_offset: usize = (7 - 1) * envelope_size;
20229
20230            // Zero reserved fields.
20231            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20232
20233            // Safety:
20234            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20235            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20236            //   envelope_size bytes, there is always sufficient room.
20237            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20238                self.packet_count_for_server_recommended
20239                    .as_ref()
20240                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20241                encoder,
20242                offset + cur_offset,
20243                depth,
20244            )?;
20245
20246            _prev_end_offset = cur_offset + envelope_size;
20247            if 8 > max_ordinal {
20248                return Ok(());
20249            }
20250
20251            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20252            // are envelope_size bytes.
20253            let cur_offset: usize = (8 - 1) * envelope_size;
20254
20255            // Zero reserved fields.
20256            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20257
20258            // Safety:
20259            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20260            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20261            //   envelope_size bytes, there is always sufficient room.
20262            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20263                self.packet_count_for_server_recommended_max
20264                    .as_ref()
20265                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20266                encoder,
20267                offset + cur_offset,
20268                depth,
20269            )?;
20270
20271            _prev_end_offset = cur_offset + envelope_size;
20272            if 9 > max_ordinal {
20273                return Ok(());
20274            }
20275
20276            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20277            // are envelope_size bytes.
20278            let cur_offset: usize = (9 - 1) * envelope_size;
20279
20280            // Zero reserved fields.
20281            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20282
20283            // Safety:
20284            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20285            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20286            //   envelope_size bytes, there is always sufficient room.
20287            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20288                self.packet_count_for_server_max
20289                    .as_ref()
20290                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20291                encoder,
20292                offset + cur_offset,
20293                depth,
20294            )?;
20295
20296            _prev_end_offset = cur_offset + envelope_size;
20297            if 10 > max_ordinal {
20298                return Ok(());
20299            }
20300
20301            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20302            // are envelope_size bytes.
20303            let cur_offset: usize = (10 - 1) * envelope_size;
20304
20305            // Zero reserved fields.
20306            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20307
20308            // Safety:
20309            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20310            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20311            //   envelope_size bytes, there is always sufficient room.
20312            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20313                self.packet_count_for_client_min
20314                    .as_ref()
20315                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20316                encoder,
20317                offset + cur_offset,
20318                depth,
20319            )?;
20320
20321            _prev_end_offset = cur_offset + envelope_size;
20322            if 11 > max_ordinal {
20323                return Ok(());
20324            }
20325
20326            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20327            // are envelope_size bytes.
20328            let cur_offset: usize = (11 - 1) * envelope_size;
20329
20330            // Zero reserved fields.
20331            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20332
20333            // Safety:
20334            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20335            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20336            //   envelope_size bytes, there is always sufficient room.
20337            fidl::encoding::encode_in_envelope_optional::<u32, D>(
20338                self.packet_count_for_client_max
20339                    .as_ref()
20340                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
20341                encoder,
20342                offset + cur_offset,
20343                depth,
20344            )?;
20345
20346            _prev_end_offset = cur_offset + envelope_size;
20347            if 12 > max_ordinal {
20348                return Ok(());
20349            }
20350
20351            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20352            // are envelope_size bytes.
20353            let cur_offset: usize = (12 - 1) * envelope_size;
20354
20355            // Zero reserved fields.
20356            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20357
20358            // Safety:
20359            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20360            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20361            //   envelope_size bytes, there is always sufficient room.
20362            fidl::encoding::encode_in_envelope_optional::<bool, D>(
20363                self.single_buffer_mode_allowed
20364                    .as_ref()
20365                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20366                encoder,
20367                offset + cur_offset,
20368                depth,
20369            )?;
20370
20371            _prev_end_offset = cur_offset + envelope_size;
20372            if 13 > max_ordinal {
20373                return Ok(());
20374            }
20375
20376            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20377            // are envelope_size bytes.
20378            let cur_offset: usize = (13 - 1) * envelope_size;
20379
20380            // Zero reserved fields.
20381            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20382
20383            // Safety:
20384            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20385            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20386            //   envelope_size bytes, there is always sufficient room.
20387            fidl::encoding::encode_in_envelope_optional::<bool, D>(
20388                self.is_physically_contiguous_required
20389                    .as_ref()
20390                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
20391                encoder,
20392                offset + cur_offset,
20393                depth,
20394            )?;
20395
20396            _prev_end_offset = cur_offset + envelope_size;
20397
20398            Ok(())
20399        }
20400    }
20401
20402    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
20403        for StreamBufferConstraints
20404    {
20405        #[inline(always)]
20406        fn new_empty() -> Self {
20407            Self::default()
20408        }
20409
20410        unsafe fn decode(
20411            &mut self,
20412            decoder: &mut fidl::encoding::Decoder<'_, D>,
20413            offset: usize,
20414            mut depth: fidl::encoding::Depth,
20415        ) -> fidl::Result<()> {
20416            decoder.debug_check_bounds::<Self>(offset);
20417            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20418                None => return Err(fidl::Error::NotNullable),
20419                Some(len) => len,
20420            };
20421            // Calling decoder.out_of_line_offset(0) is not allowed.
20422            if len == 0 {
20423                return Ok(());
20424            };
20425            depth.increment()?;
20426            let envelope_size = 8;
20427            let bytes_len = len * envelope_size;
20428            let offset = decoder.out_of_line_offset(bytes_len)?;
20429            // Decode the envelope for each type.
20430            let mut _next_ordinal_to_read = 0;
20431            let mut next_offset = offset;
20432            let end_offset = offset + bytes_len;
20433            _next_ordinal_to_read += 1;
20434            if next_offset >= end_offset {
20435                return Ok(());
20436            }
20437
20438            // Decode unknown envelopes for gaps in ordinals.
20439            while _next_ordinal_to_read < 1 {
20440                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20441                _next_ordinal_to_read += 1;
20442                next_offset += envelope_size;
20443            }
20444
20445            let next_out_of_line = decoder.next_out_of_line();
20446            let handles_before = decoder.remaining_handles();
20447            if let Some((inlined, num_bytes, num_handles)) =
20448                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20449            {
20450                let member_inline_size =
20451                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20452                if inlined != (member_inline_size <= 4) {
20453                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20454                }
20455                let inner_offset;
20456                let mut inner_depth = depth.clone();
20457                if inlined {
20458                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20459                    inner_offset = next_offset;
20460                } else {
20461                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20462                    inner_depth.increment()?;
20463                }
20464                let val_ref = self
20465                    .buffer_constraints_version_ordinal
20466                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
20467                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
20468                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20469                {
20470                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20471                }
20472                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20473                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20474                }
20475            }
20476
20477            next_offset += envelope_size;
20478            _next_ordinal_to_read += 1;
20479            if next_offset >= end_offset {
20480                return Ok(());
20481            }
20482
20483            // Decode unknown envelopes for gaps in ordinals.
20484            while _next_ordinal_to_read < 2 {
20485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20486                _next_ordinal_to_read += 1;
20487                next_offset += envelope_size;
20488            }
20489
20490            let next_out_of_line = decoder.next_out_of_line();
20491            let handles_before = decoder.remaining_handles();
20492            if let Some((inlined, num_bytes, num_handles)) =
20493                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20494            {
20495                let member_inline_size =
20496                    <StreamBufferSettings as fidl::encoding::TypeMarker>::inline_size(
20497                        decoder.context,
20498                    );
20499                if inlined != (member_inline_size <= 4) {
20500                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20501                }
20502                let inner_offset;
20503                let mut inner_depth = depth.clone();
20504                if inlined {
20505                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20506                    inner_offset = next_offset;
20507                } else {
20508                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20509                    inner_depth.increment()?;
20510                }
20511                let val_ref = self
20512                    .default_settings
20513                    .get_or_insert_with(|| fidl::new_empty!(StreamBufferSettings, D));
20514                fidl::decode!(
20515                    StreamBufferSettings,
20516                    D,
20517                    val_ref,
20518                    decoder,
20519                    inner_offset,
20520                    inner_depth
20521                )?;
20522                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20523                {
20524                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20525                }
20526                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20527                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20528                }
20529            }
20530
20531            next_offset += envelope_size;
20532            _next_ordinal_to_read += 1;
20533            if next_offset >= end_offset {
20534                return Ok(());
20535            }
20536
20537            // Decode unknown envelopes for gaps in ordinals.
20538            while _next_ordinal_to_read < 3 {
20539                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20540                _next_ordinal_to_read += 1;
20541                next_offset += envelope_size;
20542            }
20543
20544            let next_out_of_line = decoder.next_out_of_line();
20545            let handles_before = decoder.remaining_handles();
20546            if let Some((inlined, num_bytes, num_handles)) =
20547                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20548            {
20549                let member_inline_size =
20550                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20551                if inlined != (member_inline_size <= 4) {
20552                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20553                }
20554                let inner_offset;
20555                let mut inner_depth = depth.clone();
20556                if inlined {
20557                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20558                    inner_offset = next_offset;
20559                } else {
20560                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20561                    inner_depth.increment()?;
20562                }
20563                let val_ref = self
20564                    .per_packet_buffer_bytes_min
20565                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20566                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20567                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20568                {
20569                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20570                }
20571                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20572                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20573                }
20574            }
20575
20576            next_offset += envelope_size;
20577            _next_ordinal_to_read += 1;
20578            if next_offset >= end_offset {
20579                return Ok(());
20580            }
20581
20582            // Decode unknown envelopes for gaps in ordinals.
20583            while _next_ordinal_to_read < 4 {
20584                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20585                _next_ordinal_to_read += 1;
20586                next_offset += envelope_size;
20587            }
20588
20589            let next_out_of_line = decoder.next_out_of_line();
20590            let handles_before = decoder.remaining_handles();
20591            if let Some((inlined, num_bytes, num_handles)) =
20592                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20593            {
20594                let member_inline_size =
20595                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20596                if inlined != (member_inline_size <= 4) {
20597                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20598                }
20599                let inner_offset;
20600                let mut inner_depth = depth.clone();
20601                if inlined {
20602                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20603                    inner_offset = next_offset;
20604                } else {
20605                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20606                    inner_depth.increment()?;
20607                }
20608                let val_ref = self
20609                    .per_packet_buffer_bytes_recommended
20610                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20611                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20613                {
20614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20615                }
20616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20618                }
20619            }
20620
20621            next_offset += envelope_size;
20622            _next_ordinal_to_read += 1;
20623            if next_offset >= end_offset {
20624                return Ok(());
20625            }
20626
20627            // Decode unknown envelopes for gaps in ordinals.
20628            while _next_ordinal_to_read < 5 {
20629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20630                _next_ordinal_to_read += 1;
20631                next_offset += envelope_size;
20632            }
20633
20634            let next_out_of_line = decoder.next_out_of_line();
20635            let handles_before = decoder.remaining_handles();
20636            if let Some((inlined, num_bytes, num_handles)) =
20637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20638            {
20639                let member_inline_size =
20640                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20641                if inlined != (member_inline_size <= 4) {
20642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20643                }
20644                let inner_offset;
20645                let mut inner_depth = depth.clone();
20646                if inlined {
20647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20648                    inner_offset = next_offset;
20649                } else {
20650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20651                    inner_depth.increment()?;
20652                }
20653                let val_ref = self
20654                    .per_packet_buffer_bytes_max
20655                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20656                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20657                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20658                {
20659                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20660                }
20661                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20662                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20663                }
20664            }
20665
20666            next_offset += envelope_size;
20667            _next_ordinal_to_read += 1;
20668            if next_offset >= end_offset {
20669                return Ok(());
20670            }
20671
20672            // Decode unknown envelopes for gaps in ordinals.
20673            while _next_ordinal_to_read < 6 {
20674                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20675                _next_ordinal_to_read += 1;
20676                next_offset += envelope_size;
20677            }
20678
20679            let next_out_of_line = decoder.next_out_of_line();
20680            let handles_before = decoder.remaining_handles();
20681            if let Some((inlined, num_bytes, num_handles)) =
20682                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20683            {
20684                let member_inline_size =
20685                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20686                if inlined != (member_inline_size <= 4) {
20687                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20688                }
20689                let inner_offset;
20690                let mut inner_depth = depth.clone();
20691                if inlined {
20692                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20693                    inner_offset = next_offset;
20694                } else {
20695                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20696                    inner_depth.increment()?;
20697                }
20698                let val_ref = self
20699                    .packet_count_for_server_min
20700                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20701                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20702                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20703                {
20704                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20705                }
20706                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20707                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20708                }
20709            }
20710
20711            next_offset += envelope_size;
20712            _next_ordinal_to_read += 1;
20713            if next_offset >= end_offset {
20714                return Ok(());
20715            }
20716
20717            // Decode unknown envelopes for gaps in ordinals.
20718            while _next_ordinal_to_read < 7 {
20719                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20720                _next_ordinal_to_read += 1;
20721                next_offset += envelope_size;
20722            }
20723
20724            let next_out_of_line = decoder.next_out_of_line();
20725            let handles_before = decoder.remaining_handles();
20726            if let Some((inlined, num_bytes, num_handles)) =
20727                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20728            {
20729                let member_inline_size =
20730                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20731                if inlined != (member_inline_size <= 4) {
20732                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20733                }
20734                let inner_offset;
20735                let mut inner_depth = depth.clone();
20736                if inlined {
20737                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20738                    inner_offset = next_offset;
20739                } else {
20740                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20741                    inner_depth.increment()?;
20742                }
20743                let val_ref = self
20744                    .packet_count_for_server_recommended
20745                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20746                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20747                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20748                {
20749                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20750                }
20751                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20752                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20753                }
20754            }
20755
20756            next_offset += envelope_size;
20757            _next_ordinal_to_read += 1;
20758            if next_offset >= end_offset {
20759                return Ok(());
20760            }
20761
20762            // Decode unknown envelopes for gaps in ordinals.
20763            while _next_ordinal_to_read < 8 {
20764                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20765                _next_ordinal_to_read += 1;
20766                next_offset += envelope_size;
20767            }
20768
20769            let next_out_of_line = decoder.next_out_of_line();
20770            let handles_before = decoder.remaining_handles();
20771            if let Some((inlined, num_bytes, num_handles)) =
20772                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20773            {
20774                let member_inline_size =
20775                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20776                if inlined != (member_inline_size <= 4) {
20777                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20778                }
20779                let inner_offset;
20780                let mut inner_depth = depth.clone();
20781                if inlined {
20782                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20783                    inner_offset = next_offset;
20784                } else {
20785                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20786                    inner_depth.increment()?;
20787                }
20788                let val_ref = self
20789                    .packet_count_for_server_recommended_max
20790                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20791                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20792                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20793                {
20794                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20795                }
20796                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20797                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20798                }
20799            }
20800
20801            next_offset += envelope_size;
20802            _next_ordinal_to_read += 1;
20803            if next_offset >= end_offset {
20804                return Ok(());
20805            }
20806
20807            // Decode unknown envelopes for gaps in ordinals.
20808            while _next_ordinal_to_read < 9 {
20809                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20810                _next_ordinal_to_read += 1;
20811                next_offset += envelope_size;
20812            }
20813
20814            let next_out_of_line = decoder.next_out_of_line();
20815            let handles_before = decoder.remaining_handles();
20816            if let Some((inlined, num_bytes, num_handles)) =
20817                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20818            {
20819                let member_inline_size =
20820                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20821                if inlined != (member_inline_size <= 4) {
20822                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20823                }
20824                let inner_offset;
20825                let mut inner_depth = depth.clone();
20826                if inlined {
20827                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20828                    inner_offset = next_offset;
20829                } else {
20830                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20831                    inner_depth.increment()?;
20832                }
20833                let val_ref = self
20834                    .packet_count_for_server_max
20835                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20836                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20837                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20838                {
20839                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20840                }
20841                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20842                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20843                }
20844            }
20845
20846            next_offset += envelope_size;
20847            _next_ordinal_to_read += 1;
20848            if next_offset >= end_offset {
20849                return Ok(());
20850            }
20851
20852            // Decode unknown envelopes for gaps in ordinals.
20853            while _next_ordinal_to_read < 10 {
20854                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20855                _next_ordinal_to_read += 1;
20856                next_offset += envelope_size;
20857            }
20858
20859            let next_out_of_line = decoder.next_out_of_line();
20860            let handles_before = decoder.remaining_handles();
20861            if let Some((inlined, num_bytes, num_handles)) =
20862                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20863            {
20864                let member_inline_size =
20865                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20866                if inlined != (member_inline_size <= 4) {
20867                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20868                }
20869                let inner_offset;
20870                let mut inner_depth = depth.clone();
20871                if inlined {
20872                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20873                    inner_offset = next_offset;
20874                } else {
20875                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20876                    inner_depth.increment()?;
20877                }
20878                let val_ref = self
20879                    .packet_count_for_client_min
20880                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20881                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20882                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20883                {
20884                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20885                }
20886                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20887                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20888                }
20889            }
20890
20891            next_offset += envelope_size;
20892            _next_ordinal_to_read += 1;
20893            if next_offset >= end_offset {
20894                return Ok(());
20895            }
20896
20897            // Decode unknown envelopes for gaps in ordinals.
20898            while _next_ordinal_to_read < 11 {
20899                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20900                _next_ordinal_to_read += 1;
20901                next_offset += envelope_size;
20902            }
20903
20904            let next_out_of_line = decoder.next_out_of_line();
20905            let handles_before = decoder.remaining_handles();
20906            if let Some((inlined, num_bytes, num_handles)) =
20907                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20908            {
20909                let member_inline_size =
20910                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20911                if inlined != (member_inline_size <= 4) {
20912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20913                }
20914                let inner_offset;
20915                let mut inner_depth = depth.clone();
20916                if inlined {
20917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20918                    inner_offset = next_offset;
20919                } else {
20920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20921                    inner_depth.increment()?;
20922                }
20923                let val_ref = self
20924                    .packet_count_for_client_max
20925                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
20926                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
20927                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20928                {
20929                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20930                }
20931                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20932                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20933                }
20934            }
20935
20936            next_offset += envelope_size;
20937            _next_ordinal_to_read += 1;
20938            if next_offset >= end_offset {
20939                return Ok(());
20940            }
20941
20942            // Decode unknown envelopes for gaps in ordinals.
20943            while _next_ordinal_to_read < 12 {
20944                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20945                _next_ordinal_to_read += 1;
20946                next_offset += envelope_size;
20947            }
20948
20949            let next_out_of_line = decoder.next_out_of_line();
20950            let handles_before = decoder.remaining_handles();
20951            if let Some((inlined, num_bytes, num_handles)) =
20952                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20953            {
20954                let member_inline_size =
20955                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20956                if inlined != (member_inline_size <= 4) {
20957                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20958                }
20959                let inner_offset;
20960                let mut inner_depth = depth.clone();
20961                if inlined {
20962                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20963                    inner_offset = next_offset;
20964                } else {
20965                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20966                    inner_depth.increment()?;
20967                }
20968                let val_ref = self
20969                    .single_buffer_mode_allowed
20970                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
20971                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
20972                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20973                {
20974                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20975                }
20976                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20977                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20978                }
20979            }
20980
20981            next_offset += envelope_size;
20982            _next_ordinal_to_read += 1;
20983            if next_offset >= end_offset {
20984                return Ok(());
20985            }
20986
20987            // Decode unknown envelopes for gaps in ordinals.
20988            while _next_ordinal_to_read < 13 {
20989                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20990                _next_ordinal_to_read += 1;
20991                next_offset += envelope_size;
20992            }
20993
20994            let next_out_of_line = decoder.next_out_of_line();
20995            let handles_before = decoder.remaining_handles();
20996            if let Some((inlined, num_bytes, num_handles)) =
20997                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20998            {
20999                let member_inline_size =
21000                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21001                if inlined != (member_inline_size <= 4) {
21002                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21003                }
21004                let inner_offset;
21005                let mut inner_depth = depth.clone();
21006                if inlined {
21007                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21008                    inner_offset = next_offset;
21009                } else {
21010                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21011                    inner_depth.increment()?;
21012                }
21013                let val_ref = self
21014                    .is_physically_contiguous_required
21015                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
21016                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21017                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21018                {
21019                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21020                }
21021                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21022                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21023                }
21024            }
21025
21026            next_offset += envelope_size;
21027
21028            // Decode the remaining unknown envelopes.
21029            while next_offset < end_offset {
21030                _next_ordinal_to_read += 1;
21031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21032                next_offset += envelope_size;
21033            }
21034
21035            Ok(())
21036        }
21037    }
21038
21039    impl StreamBufferSettings {
21040        #[inline(always)]
21041        fn max_ordinal_present(&self) -> u64 {
21042            if let Some(_) = self.single_buffer_mode {
21043                return 6;
21044            }
21045            if let Some(_) = self.per_packet_buffer_bytes {
21046                return 5;
21047            }
21048            if let Some(_) = self.packet_count_for_client {
21049                return 4;
21050            }
21051            if let Some(_) = self.packet_count_for_server {
21052                return 3;
21053            }
21054            if let Some(_) = self.buffer_constraints_version_ordinal {
21055                return 2;
21056            }
21057            if let Some(_) = self.buffer_lifetime_ordinal {
21058                return 1;
21059            }
21060            0
21061        }
21062    }
21063
21064    impl fidl::encoding::ValueTypeMarker for StreamBufferSettings {
21065        type Borrowed<'a> = &'a Self;
21066        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21067            value
21068        }
21069    }
21070
21071    unsafe impl fidl::encoding::TypeMarker for StreamBufferSettings {
21072        type Owned = Self;
21073
21074        #[inline(always)]
21075        fn inline_align(_context: fidl::encoding::Context) -> usize {
21076            8
21077        }
21078
21079        #[inline(always)]
21080        fn inline_size(_context: fidl::encoding::Context) -> usize {
21081            16
21082        }
21083    }
21084
21085    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamBufferSettings, D>
21086        for &StreamBufferSettings
21087    {
21088        unsafe fn encode(
21089            self,
21090            encoder: &mut fidl::encoding::Encoder<'_, D>,
21091            offset: usize,
21092            mut depth: fidl::encoding::Depth,
21093        ) -> fidl::Result<()> {
21094            encoder.debug_check_bounds::<StreamBufferSettings>(offset);
21095            // Vector header
21096            let max_ordinal: u64 = self.max_ordinal_present();
21097            encoder.write_num(max_ordinal, offset);
21098            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21099            // Calling encoder.out_of_line_offset(0) is not allowed.
21100            if max_ordinal == 0 {
21101                return Ok(());
21102            }
21103            depth.increment()?;
21104            let envelope_size = 8;
21105            let bytes_len = max_ordinal as usize * envelope_size;
21106            #[allow(unused_variables)]
21107            let offset = encoder.out_of_line_offset(bytes_len);
21108            let mut _prev_end_offset: usize = 0;
21109            if 1 > max_ordinal {
21110                return Ok(());
21111            }
21112
21113            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21114            // are envelope_size bytes.
21115            let cur_offset: usize = (1 - 1) * envelope_size;
21116
21117            // Zero reserved fields.
21118            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21119
21120            // Safety:
21121            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21122            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21123            //   envelope_size bytes, there is always sufficient room.
21124            fidl::encoding::encode_in_envelope_optional::<u64, D>(
21125                self.buffer_lifetime_ordinal
21126                    .as_ref()
21127                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21128                encoder,
21129                offset + cur_offset,
21130                depth,
21131            )?;
21132
21133            _prev_end_offset = cur_offset + envelope_size;
21134            if 2 > max_ordinal {
21135                return Ok(());
21136            }
21137
21138            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21139            // are envelope_size bytes.
21140            let cur_offset: usize = (2 - 1) * envelope_size;
21141
21142            // Zero reserved fields.
21143            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21144
21145            // Safety:
21146            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21147            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21148            //   envelope_size bytes, there is always sufficient room.
21149            fidl::encoding::encode_in_envelope_optional::<u64, D>(
21150                self.buffer_constraints_version_ordinal
21151                    .as_ref()
21152                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21153                encoder,
21154                offset + cur_offset,
21155                depth,
21156            )?;
21157
21158            _prev_end_offset = cur_offset + envelope_size;
21159            if 3 > max_ordinal {
21160                return Ok(());
21161            }
21162
21163            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21164            // are envelope_size bytes.
21165            let cur_offset: usize = (3 - 1) * envelope_size;
21166
21167            // Zero reserved fields.
21168            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21169
21170            // Safety:
21171            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21172            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21173            //   envelope_size bytes, there is always sufficient room.
21174            fidl::encoding::encode_in_envelope_optional::<u32, D>(
21175                self.packet_count_for_server
21176                    .as_ref()
21177                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21178                encoder,
21179                offset + cur_offset,
21180                depth,
21181            )?;
21182
21183            _prev_end_offset = cur_offset + envelope_size;
21184            if 4 > max_ordinal {
21185                return Ok(());
21186            }
21187
21188            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21189            // are envelope_size bytes.
21190            let cur_offset: usize = (4 - 1) * envelope_size;
21191
21192            // Zero reserved fields.
21193            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21194
21195            // Safety:
21196            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21197            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21198            //   envelope_size bytes, there is always sufficient room.
21199            fidl::encoding::encode_in_envelope_optional::<u32, D>(
21200                self.packet_count_for_client
21201                    .as_ref()
21202                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21203                encoder,
21204                offset + cur_offset,
21205                depth,
21206            )?;
21207
21208            _prev_end_offset = cur_offset + envelope_size;
21209            if 5 > max_ordinal {
21210                return Ok(());
21211            }
21212
21213            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21214            // are envelope_size bytes.
21215            let cur_offset: usize = (5 - 1) * envelope_size;
21216
21217            // Zero reserved fields.
21218            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21219
21220            // Safety:
21221            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21222            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21223            //   envelope_size bytes, there is always sufficient room.
21224            fidl::encoding::encode_in_envelope_optional::<u32, D>(
21225                self.per_packet_buffer_bytes
21226                    .as_ref()
21227                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
21228                encoder,
21229                offset + cur_offset,
21230                depth,
21231            )?;
21232
21233            _prev_end_offset = cur_offset + envelope_size;
21234            if 6 > max_ordinal {
21235                return Ok(());
21236            }
21237
21238            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21239            // are envelope_size bytes.
21240            let cur_offset: usize = (6 - 1) * envelope_size;
21241
21242            // Zero reserved fields.
21243            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21244
21245            // Safety:
21246            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21247            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21248            //   envelope_size bytes, there is always sufficient room.
21249            fidl::encoding::encode_in_envelope_optional::<bool, D>(
21250                self.single_buffer_mode
21251                    .as_ref()
21252                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21253                encoder,
21254                offset + cur_offset,
21255                depth,
21256            )?;
21257
21258            _prev_end_offset = cur_offset + envelope_size;
21259
21260            Ok(())
21261        }
21262    }
21263
21264    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamBufferSettings {
21265        #[inline(always)]
21266        fn new_empty() -> Self {
21267            Self::default()
21268        }
21269
21270        unsafe fn decode(
21271            &mut self,
21272            decoder: &mut fidl::encoding::Decoder<'_, D>,
21273            offset: usize,
21274            mut depth: fidl::encoding::Depth,
21275        ) -> fidl::Result<()> {
21276            decoder.debug_check_bounds::<Self>(offset);
21277            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21278                None => return Err(fidl::Error::NotNullable),
21279                Some(len) => len,
21280            };
21281            // Calling decoder.out_of_line_offset(0) is not allowed.
21282            if len == 0 {
21283                return Ok(());
21284            };
21285            depth.increment()?;
21286            let envelope_size = 8;
21287            let bytes_len = len * envelope_size;
21288            let offset = decoder.out_of_line_offset(bytes_len)?;
21289            // Decode the envelope for each type.
21290            let mut _next_ordinal_to_read = 0;
21291            let mut next_offset = offset;
21292            let end_offset = offset + bytes_len;
21293            _next_ordinal_to_read += 1;
21294            if next_offset >= end_offset {
21295                return Ok(());
21296            }
21297
21298            // Decode unknown envelopes for gaps in ordinals.
21299            while _next_ordinal_to_read < 1 {
21300                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21301                _next_ordinal_to_read += 1;
21302                next_offset += envelope_size;
21303            }
21304
21305            let next_out_of_line = decoder.next_out_of_line();
21306            let handles_before = decoder.remaining_handles();
21307            if let Some((inlined, num_bytes, num_handles)) =
21308                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21309            {
21310                let member_inline_size =
21311                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21312                if inlined != (member_inline_size <= 4) {
21313                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21314                }
21315                let inner_offset;
21316                let mut inner_depth = depth.clone();
21317                if inlined {
21318                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21319                    inner_offset = next_offset;
21320                } else {
21321                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21322                    inner_depth.increment()?;
21323                }
21324                let val_ref =
21325                    self.buffer_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21326                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21327                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21328                {
21329                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21330                }
21331                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21332                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21333                }
21334            }
21335
21336            next_offset += envelope_size;
21337            _next_ordinal_to_read += 1;
21338            if next_offset >= end_offset {
21339                return Ok(());
21340            }
21341
21342            // Decode unknown envelopes for gaps in ordinals.
21343            while _next_ordinal_to_read < 2 {
21344                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21345                _next_ordinal_to_read += 1;
21346                next_offset += envelope_size;
21347            }
21348
21349            let next_out_of_line = decoder.next_out_of_line();
21350            let handles_before = decoder.remaining_handles();
21351            if let Some((inlined, num_bytes, num_handles)) =
21352                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21353            {
21354                let member_inline_size =
21355                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21356                if inlined != (member_inline_size <= 4) {
21357                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21358                }
21359                let inner_offset;
21360                let mut inner_depth = depth.clone();
21361                if inlined {
21362                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21363                    inner_offset = next_offset;
21364                } else {
21365                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21366                    inner_depth.increment()?;
21367                }
21368                let val_ref = self
21369                    .buffer_constraints_version_ordinal
21370                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
21371                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21373                {
21374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21375                }
21376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21378                }
21379            }
21380
21381            next_offset += envelope_size;
21382            _next_ordinal_to_read += 1;
21383            if next_offset >= end_offset {
21384                return Ok(());
21385            }
21386
21387            // Decode unknown envelopes for gaps in ordinals.
21388            while _next_ordinal_to_read < 3 {
21389                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21390                _next_ordinal_to_read += 1;
21391                next_offset += envelope_size;
21392            }
21393
21394            let next_out_of_line = decoder.next_out_of_line();
21395            let handles_before = decoder.remaining_handles();
21396            if let Some((inlined, num_bytes, num_handles)) =
21397                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21398            {
21399                let member_inline_size =
21400                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21401                if inlined != (member_inline_size <= 4) {
21402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21403                }
21404                let inner_offset;
21405                let mut inner_depth = depth.clone();
21406                if inlined {
21407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21408                    inner_offset = next_offset;
21409                } else {
21410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21411                    inner_depth.increment()?;
21412                }
21413                let val_ref =
21414                    self.packet_count_for_server.get_or_insert_with(|| fidl::new_empty!(u32, D));
21415                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21416                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21417                {
21418                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21419                }
21420                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21421                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21422                }
21423            }
21424
21425            next_offset += envelope_size;
21426            _next_ordinal_to_read += 1;
21427            if next_offset >= end_offset {
21428                return Ok(());
21429            }
21430
21431            // Decode unknown envelopes for gaps in ordinals.
21432            while _next_ordinal_to_read < 4 {
21433                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21434                _next_ordinal_to_read += 1;
21435                next_offset += envelope_size;
21436            }
21437
21438            let next_out_of_line = decoder.next_out_of_line();
21439            let handles_before = decoder.remaining_handles();
21440            if let Some((inlined, num_bytes, num_handles)) =
21441                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21442            {
21443                let member_inline_size =
21444                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21445                if inlined != (member_inline_size <= 4) {
21446                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21447                }
21448                let inner_offset;
21449                let mut inner_depth = depth.clone();
21450                if inlined {
21451                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21452                    inner_offset = next_offset;
21453                } else {
21454                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21455                    inner_depth.increment()?;
21456                }
21457                let val_ref =
21458                    self.packet_count_for_client.get_or_insert_with(|| fidl::new_empty!(u32, D));
21459                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21460                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21461                {
21462                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21463                }
21464                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21465                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21466                }
21467            }
21468
21469            next_offset += envelope_size;
21470            _next_ordinal_to_read += 1;
21471            if next_offset >= end_offset {
21472                return Ok(());
21473            }
21474
21475            // Decode unknown envelopes for gaps in ordinals.
21476            while _next_ordinal_to_read < 5 {
21477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21478                _next_ordinal_to_read += 1;
21479                next_offset += envelope_size;
21480            }
21481
21482            let next_out_of_line = decoder.next_out_of_line();
21483            let handles_before = decoder.remaining_handles();
21484            if let Some((inlined, num_bytes, num_handles)) =
21485                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21486            {
21487                let member_inline_size =
21488                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21489                if inlined != (member_inline_size <= 4) {
21490                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21491                }
21492                let inner_offset;
21493                let mut inner_depth = depth.clone();
21494                if inlined {
21495                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21496                    inner_offset = next_offset;
21497                } else {
21498                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21499                    inner_depth.increment()?;
21500                }
21501                let val_ref =
21502                    self.per_packet_buffer_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
21503                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
21504                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21505                {
21506                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21507                }
21508                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21509                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21510                }
21511            }
21512
21513            next_offset += envelope_size;
21514            _next_ordinal_to_read += 1;
21515            if next_offset >= end_offset {
21516                return Ok(());
21517            }
21518
21519            // Decode unknown envelopes for gaps in ordinals.
21520            while _next_ordinal_to_read < 6 {
21521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21522                _next_ordinal_to_read += 1;
21523                next_offset += envelope_size;
21524            }
21525
21526            let next_out_of_line = decoder.next_out_of_line();
21527            let handles_before = decoder.remaining_handles();
21528            if let Some((inlined, num_bytes, num_handles)) =
21529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21530            {
21531                let member_inline_size =
21532                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21533                if inlined != (member_inline_size <= 4) {
21534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21535                }
21536                let inner_offset;
21537                let mut inner_depth = depth.clone();
21538                if inlined {
21539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21540                    inner_offset = next_offset;
21541                } else {
21542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21543                    inner_depth.increment()?;
21544                }
21545                let val_ref =
21546                    self.single_buffer_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
21547                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21548                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21549                {
21550                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21551                }
21552                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21553                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21554                }
21555            }
21556
21557            next_offset += envelope_size;
21558
21559            // Decode the remaining unknown envelopes.
21560            while next_offset < end_offset {
21561                _next_ordinal_to_read += 1;
21562                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21563                next_offset += envelope_size;
21564            }
21565
21566            Ok(())
21567        }
21568    }
21569
21570    impl StreamOutputConstraints {
21571        #[inline(always)]
21572        fn max_ordinal_present(&self) -> u64 {
21573            if let Some(_) = self.buffer_constraints {
21574                return 3;
21575            }
21576            if let Some(_) = self.buffer_constraints_action_required {
21577                return 2;
21578            }
21579            if let Some(_) = self.stream_lifetime_ordinal {
21580                return 1;
21581            }
21582            0
21583        }
21584    }
21585
21586    impl fidl::encoding::ValueTypeMarker for StreamOutputConstraints {
21587        type Borrowed<'a> = &'a Self;
21588        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21589            value
21590        }
21591    }
21592
21593    unsafe impl fidl::encoding::TypeMarker for StreamOutputConstraints {
21594        type Owned = Self;
21595
21596        #[inline(always)]
21597        fn inline_align(_context: fidl::encoding::Context) -> usize {
21598            8
21599        }
21600
21601        #[inline(always)]
21602        fn inline_size(_context: fidl::encoding::Context) -> usize {
21603            16
21604        }
21605    }
21606
21607    unsafe impl<D: fidl::encoding::ResourceDialect>
21608        fidl::encoding::Encode<StreamOutputConstraints, D> for &StreamOutputConstraints
21609    {
21610        unsafe fn encode(
21611            self,
21612            encoder: &mut fidl::encoding::Encoder<'_, D>,
21613            offset: usize,
21614            mut depth: fidl::encoding::Depth,
21615        ) -> fidl::Result<()> {
21616            encoder.debug_check_bounds::<StreamOutputConstraints>(offset);
21617            // Vector header
21618            let max_ordinal: u64 = self.max_ordinal_present();
21619            encoder.write_num(max_ordinal, offset);
21620            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21621            // Calling encoder.out_of_line_offset(0) is not allowed.
21622            if max_ordinal == 0 {
21623                return Ok(());
21624            }
21625            depth.increment()?;
21626            let envelope_size = 8;
21627            let bytes_len = max_ordinal as usize * envelope_size;
21628            #[allow(unused_variables)]
21629            let offset = encoder.out_of_line_offset(bytes_len);
21630            let mut _prev_end_offset: usize = 0;
21631            if 1 > max_ordinal {
21632                return Ok(());
21633            }
21634
21635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21636            // are envelope_size bytes.
21637            let cur_offset: usize = (1 - 1) * envelope_size;
21638
21639            // Zero reserved fields.
21640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21641
21642            // Safety:
21643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21645            //   envelope_size bytes, there is always sufficient room.
21646            fidl::encoding::encode_in_envelope_optional::<u64, D>(
21647                self.stream_lifetime_ordinal
21648                    .as_ref()
21649                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21650                encoder,
21651                offset + cur_offset,
21652                depth,
21653            )?;
21654
21655            _prev_end_offset = cur_offset + envelope_size;
21656            if 2 > max_ordinal {
21657                return Ok(());
21658            }
21659
21660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21661            // are envelope_size bytes.
21662            let cur_offset: usize = (2 - 1) * envelope_size;
21663
21664            // Zero reserved fields.
21665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21666
21667            // Safety:
21668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21670            //   envelope_size bytes, there is always sufficient room.
21671            fidl::encoding::encode_in_envelope_optional::<bool, D>(
21672                self.buffer_constraints_action_required
21673                    .as_ref()
21674                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
21675                encoder,
21676                offset + cur_offset,
21677                depth,
21678            )?;
21679
21680            _prev_end_offset = cur_offset + envelope_size;
21681            if 3 > max_ordinal {
21682                return Ok(());
21683            }
21684
21685            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21686            // are envelope_size bytes.
21687            let cur_offset: usize = (3 - 1) * envelope_size;
21688
21689            // Zero reserved fields.
21690            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21691
21692            // Safety:
21693            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21694            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21695            //   envelope_size bytes, there is always sufficient room.
21696            fidl::encoding::encode_in_envelope_optional::<StreamBufferConstraints, D>(
21697                self.buffer_constraints
21698                    .as_ref()
21699                    .map(<StreamBufferConstraints as fidl::encoding::ValueTypeMarker>::borrow),
21700                encoder,
21701                offset + cur_offset,
21702                depth,
21703            )?;
21704
21705            _prev_end_offset = cur_offset + envelope_size;
21706
21707            Ok(())
21708        }
21709    }
21710
21711    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
21712        for StreamOutputConstraints
21713    {
21714        #[inline(always)]
21715        fn new_empty() -> Self {
21716            Self::default()
21717        }
21718
21719        unsafe fn decode(
21720            &mut self,
21721            decoder: &mut fidl::encoding::Decoder<'_, D>,
21722            offset: usize,
21723            mut depth: fidl::encoding::Depth,
21724        ) -> fidl::Result<()> {
21725            decoder.debug_check_bounds::<Self>(offset);
21726            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21727                None => return Err(fidl::Error::NotNullable),
21728                Some(len) => len,
21729            };
21730            // Calling decoder.out_of_line_offset(0) is not allowed.
21731            if len == 0 {
21732                return Ok(());
21733            };
21734            depth.increment()?;
21735            let envelope_size = 8;
21736            let bytes_len = len * envelope_size;
21737            let offset = decoder.out_of_line_offset(bytes_len)?;
21738            // Decode the envelope for each type.
21739            let mut _next_ordinal_to_read = 0;
21740            let mut next_offset = offset;
21741            let end_offset = offset + bytes_len;
21742            _next_ordinal_to_read += 1;
21743            if next_offset >= end_offset {
21744                return Ok(());
21745            }
21746
21747            // Decode unknown envelopes for gaps in ordinals.
21748            while _next_ordinal_to_read < 1 {
21749                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21750                _next_ordinal_to_read += 1;
21751                next_offset += envelope_size;
21752            }
21753
21754            let next_out_of_line = decoder.next_out_of_line();
21755            let handles_before = decoder.remaining_handles();
21756            if let Some((inlined, num_bytes, num_handles)) =
21757                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21758            {
21759                let member_inline_size =
21760                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21761                if inlined != (member_inline_size <= 4) {
21762                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21763                }
21764                let inner_offset;
21765                let mut inner_depth = depth.clone();
21766                if inlined {
21767                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21768                    inner_offset = next_offset;
21769                } else {
21770                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21771                    inner_depth.increment()?;
21772                }
21773                let val_ref =
21774                    self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
21775                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
21776                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21777                {
21778                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21779                }
21780                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21781                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21782                }
21783            }
21784
21785            next_offset += envelope_size;
21786            _next_ordinal_to_read += 1;
21787            if next_offset >= end_offset {
21788                return Ok(());
21789            }
21790
21791            // Decode unknown envelopes for gaps in ordinals.
21792            while _next_ordinal_to_read < 2 {
21793                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21794                _next_ordinal_to_read += 1;
21795                next_offset += envelope_size;
21796            }
21797
21798            let next_out_of_line = decoder.next_out_of_line();
21799            let handles_before = decoder.remaining_handles();
21800            if let Some((inlined, num_bytes, num_handles)) =
21801                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21802            {
21803                let member_inline_size =
21804                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21805                if inlined != (member_inline_size <= 4) {
21806                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21807                }
21808                let inner_offset;
21809                let mut inner_depth = depth.clone();
21810                if inlined {
21811                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21812                    inner_offset = next_offset;
21813                } else {
21814                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21815                    inner_depth.increment()?;
21816                }
21817                let val_ref = self
21818                    .buffer_constraints_action_required
21819                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
21820                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
21821                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21822                {
21823                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21824                }
21825                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21826                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21827                }
21828            }
21829
21830            next_offset += envelope_size;
21831            _next_ordinal_to_read += 1;
21832            if next_offset >= end_offset {
21833                return Ok(());
21834            }
21835
21836            // Decode unknown envelopes for gaps in ordinals.
21837            while _next_ordinal_to_read < 3 {
21838                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21839                _next_ordinal_to_read += 1;
21840                next_offset += envelope_size;
21841            }
21842
21843            let next_out_of_line = decoder.next_out_of_line();
21844            let handles_before = decoder.remaining_handles();
21845            if let Some((inlined, num_bytes, num_handles)) =
21846                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21847            {
21848                let member_inline_size =
21849                    <StreamBufferConstraints as fidl::encoding::TypeMarker>::inline_size(
21850                        decoder.context,
21851                    );
21852                if inlined != (member_inline_size <= 4) {
21853                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21854                }
21855                let inner_offset;
21856                let mut inner_depth = depth.clone();
21857                if inlined {
21858                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21859                    inner_offset = next_offset;
21860                } else {
21861                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21862                    inner_depth.increment()?;
21863                }
21864                let val_ref = self
21865                    .buffer_constraints
21866                    .get_or_insert_with(|| fidl::new_empty!(StreamBufferConstraints, D));
21867                fidl::decode!(
21868                    StreamBufferConstraints,
21869                    D,
21870                    val_ref,
21871                    decoder,
21872                    inner_offset,
21873                    inner_depth
21874                )?;
21875                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21876                {
21877                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21878                }
21879                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21880                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21881                }
21882            }
21883
21884            next_offset += envelope_size;
21885
21886            // Decode the remaining unknown envelopes.
21887            while next_offset < end_offset {
21888                _next_ordinal_to_read += 1;
21889                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21890                next_offset += envelope_size;
21891            }
21892
21893            Ok(())
21894        }
21895    }
21896
21897    impl StreamOutputFormat {
21898        #[inline(always)]
21899        fn max_ordinal_present(&self) -> u64 {
21900            if let Some(_) = self.format_details {
21901                return 2;
21902            }
21903            if let Some(_) = self.stream_lifetime_ordinal {
21904                return 1;
21905            }
21906            0
21907        }
21908    }
21909
21910    impl fidl::encoding::ValueTypeMarker for StreamOutputFormat {
21911        type Borrowed<'a> = &'a Self;
21912        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21913            value
21914        }
21915    }
21916
21917    unsafe impl fidl::encoding::TypeMarker for StreamOutputFormat {
21918        type Owned = Self;
21919
21920        #[inline(always)]
21921        fn inline_align(_context: fidl::encoding::Context) -> usize {
21922            8
21923        }
21924
21925        #[inline(always)]
21926        fn inline_size(_context: fidl::encoding::Context) -> usize {
21927            16
21928        }
21929    }
21930
21931    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamOutputFormat, D>
21932        for &StreamOutputFormat
21933    {
21934        unsafe fn encode(
21935            self,
21936            encoder: &mut fidl::encoding::Encoder<'_, D>,
21937            offset: usize,
21938            mut depth: fidl::encoding::Depth,
21939        ) -> fidl::Result<()> {
21940            encoder.debug_check_bounds::<StreamOutputFormat>(offset);
21941            // Vector header
21942            let max_ordinal: u64 = self.max_ordinal_present();
21943            encoder.write_num(max_ordinal, offset);
21944            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21945            // Calling encoder.out_of_line_offset(0) is not allowed.
21946            if max_ordinal == 0 {
21947                return Ok(());
21948            }
21949            depth.increment()?;
21950            let envelope_size = 8;
21951            let bytes_len = max_ordinal as usize * envelope_size;
21952            #[allow(unused_variables)]
21953            let offset = encoder.out_of_line_offset(bytes_len);
21954            let mut _prev_end_offset: usize = 0;
21955            if 1 > max_ordinal {
21956                return Ok(());
21957            }
21958
21959            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21960            // are envelope_size bytes.
21961            let cur_offset: usize = (1 - 1) * envelope_size;
21962
21963            // Zero reserved fields.
21964            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21965
21966            // Safety:
21967            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21968            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21969            //   envelope_size bytes, there is always sufficient room.
21970            fidl::encoding::encode_in_envelope_optional::<u64, D>(
21971                self.stream_lifetime_ordinal
21972                    .as_ref()
21973                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
21974                encoder,
21975                offset + cur_offset,
21976                depth,
21977            )?;
21978
21979            _prev_end_offset = cur_offset + envelope_size;
21980            if 2 > max_ordinal {
21981                return Ok(());
21982            }
21983
21984            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21985            // are envelope_size bytes.
21986            let cur_offset: usize = (2 - 1) * envelope_size;
21987
21988            // Zero reserved fields.
21989            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21990
21991            // Safety:
21992            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21993            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21994            //   envelope_size bytes, there is always sufficient room.
21995            fidl::encoding::encode_in_envelope_optional::<FormatDetails, D>(
21996                self.format_details
21997                    .as_ref()
21998                    .map(<FormatDetails as fidl::encoding::ValueTypeMarker>::borrow),
21999                encoder,
22000                offset + cur_offset,
22001                depth,
22002            )?;
22003
22004            _prev_end_offset = cur_offset + envelope_size;
22005
22006            Ok(())
22007        }
22008    }
22009
22010    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamOutputFormat {
22011        #[inline(always)]
22012        fn new_empty() -> Self {
22013            Self::default()
22014        }
22015
22016        unsafe fn decode(
22017            &mut self,
22018            decoder: &mut fidl::encoding::Decoder<'_, D>,
22019            offset: usize,
22020            mut depth: fidl::encoding::Depth,
22021        ) -> fidl::Result<()> {
22022            decoder.debug_check_bounds::<Self>(offset);
22023            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22024                None => return Err(fidl::Error::NotNullable),
22025                Some(len) => len,
22026            };
22027            // Calling decoder.out_of_line_offset(0) is not allowed.
22028            if len == 0 {
22029                return Ok(());
22030            };
22031            depth.increment()?;
22032            let envelope_size = 8;
22033            let bytes_len = len * envelope_size;
22034            let offset = decoder.out_of_line_offset(bytes_len)?;
22035            // Decode the envelope for each type.
22036            let mut _next_ordinal_to_read = 0;
22037            let mut next_offset = offset;
22038            let end_offset = offset + bytes_len;
22039            _next_ordinal_to_read += 1;
22040            if next_offset >= end_offset {
22041                return Ok(());
22042            }
22043
22044            // Decode unknown envelopes for gaps in ordinals.
22045            while _next_ordinal_to_read < 1 {
22046                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22047                _next_ordinal_to_read += 1;
22048                next_offset += envelope_size;
22049            }
22050
22051            let next_out_of_line = decoder.next_out_of_line();
22052            let handles_before = decoder.remaining_handles();
22053            if let Some((inlined, num_bytes, num_handles)) =
22054                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22055            {
22056                let member_inline_size =
22057                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22058                if inlined != (member_inline_size <= 4) {
22059                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22060                }
22061                let inner_offset;
22062                let mut inner_depth = depth.clone();
22063                if inlined {
22064                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22065                    inner_offset = next_offset;
22066                } else {
22067                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22068                    inner_depth.increment()?;
22069                }
22070                let val_ref =
22071                    self.stream_lifetime_ordinal.get_or_insert_with(|| fidl::new_empty!(u64, D));
22072                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
22073                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22074                {
22075                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22076                }
22077                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22078                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22079                }
22080            }
22081
22082            next_offset += envelope_size;
22083            _next_ordinal_to_read += 1;
22084            if next_offset >= end_offset {
22085                return Ok(());
22086            }
22087
22088            // Decode unknown envelopes for gaps in ordinals.
22089            while _next_ordinal_to_read < 2 {
22090                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22091                _next_ordinal_to_read += 1;
22092                next_offset += envelope_size;
22093            }
22094
22095            let next_out_of_line = decoder.next_out_of_line();
22096            let handles_before = decoder.remaining_handles();
22097            if let Some((inlined, num_bytes, num_handles)) =
22098                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22099            {
22100                let member_inline_size =
22101                    <FormatDetails as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22102                if inlined != (member_inline_size <= 4) {
22103                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22104                }
22105                let inner_offset;
22106                let mut inner_depth = depth.clone();
22107                if inlined {
22108                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22109                    inner_offset = next_offset;
22110                } else {
22111                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22112                    inner_depth.increment()?;
22113                }
22114                let val_ref =
22115                    self.format_details.get_or_insert_with(|| fidl::new_empty!(FormatDetails, D));
22116                fidl::decode!(FormatDetails, D, val_ref, decoder, inner_offset, inner_depth)?;
22117                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22118                {
22119                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22120                }
22121                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22122                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22123                }
22124            }
22125
22126            next_offset += envelope_size;
22127
22128            // Decode the remaining unknown envelopes.
22129            while next_offset < end_offset {
22130                _next_ordinal_to_read += 1;
22131                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22132                next_offset += envelope_size;
22133            }
22134
22135            Ok(())
22136        }
22137    }
22138
22139    impl UsageStateDucked {
22140        #[inline(always)]
22141        fn max_ordinal_present(&self) -> u64 {
22142            0
22143        }
22144    }
22145
22146    impl fidl::encoding::ValueTypeMarker for UsageStateDucked {
22147        type Borrowed<'a> = &'a Self;
22148        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22149            value
22150        }
22151    }
22152
22153    unsafe impl fidl::encoding::TypeMarker for UsageStateDucked {
22154        type Owned = Self;
22155
22156        #[inline(always)]
22157        fn inline_align(_context: fidl::encoding::Context) -> usize {
22158            8
22159        }
22160
22161        #[inline(always)]
22162        fn inline_size(_context: fidl::encoding::Context) -> usize {
22163            16
22164        }
22165    }
22166
22167    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateDucked, D>
22168        for &UsageStateDucked
22169    {
22170        unsafe fn encode(
22171            self,
22172            encoder: &mut fidl::encoding::Encoder<'_, D>,
22173            offset: usize,
22174            mut depth: fidl::encoding::Depth,
22175        ) -> fidl::Result<()> {
22176            encoder.debug_check_bounds::<UsageStateDucked>(offset);
22177            // Vector header
22178            let max_ordinal: u64 = self.max_ordinal_present();
22179            encoder.write_num(max_ordinal, offset);
22180            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22181            // Calling encoder.out_of_line_offset(0) is not allowed.
22182            if max_ordinal == 0 {
22183                return Ok(());
22184            }
22185            depth.increment()?;
22186            let envelope_size = 8;
22187            let bytes_len = max_ordinal as usize * envelope_size;
22188            #[allow(unused_variables)]
22189            let offset = encoder.out_of_line_offset(bytes_len);
22190            let mut _prev_end_offset: usize = 0;
22191
22192            Ok(())
22193        }
22194    }
22195
22196    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateDucked {
22197        #[inline(always)]
22198        fn new_empty() -> Self {
22199            Self::default()
22200        }
22201
22202        unsafe fn decode(
22203            &mut self,
22204            decoder: &mut fidl::encoding::Decoder<'_, D>,
22205            offset: usize,
22206            mut depth: fidl::encoding::Depth,
22207        ) -> fidl::Result<()> {
22208            decoder.debug_check_bounds::<Self>(offset);
22209            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22210                None => return Err(fidl::Error::NotNullable),
22211                Some(len) => len,
22212            };
22213            // Calling decoder.out_of_line_offset(0) is not allowed.
22214            if len == 0 {
22215                return Ok(());
22216            };
22217            depth.increment()?;
22218            let envelope_size = 8;
22219            let bytes_len = len * envelope_size;
22220            let offset = decoder.out_of_line_offset(bytes_len)?;
22221            // Decode the envelope for each type.
22222            let mut _next_ordinal_to_read = 0;
22223            let mut next_offset = offset;
22224            let end_offset = offset + bytes_len;
22225
22226            // Decode the remaining unknown envelopes.
22227            while next_offset < end_offset {
22228                _next_ordinal_to_read += 1;
22229                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22230                next_offset += envelope_size;
22231            }
22232
22233            Ok(())
22234        }
22235    }
22236
22237    impl UsageStateMuted {
22238        #[inline(always)]
22239        fn max_ordinal_present(&self) -> u64 {
22240            0
22241        }
22242    }
22243
22244    impl fidl::encoding::ValueTypeMarker for UsageStateMuted {
22245        type Borrowed<'a> = &'a Self;
22246        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22247            value
22248        }
22249    }
22250
22251    unsafe impl fidl::encoding::TypeMarker for UsageStateMuted {
22252        type Owned = Self;
22253
22254        #[inline(always)]
22255        fn inline_align(_context: fidl::encoding::Context) -> usize {
22256            8
22257        }
22258
22259        #[inline(always)]
22260        fn inline_size(_context: fidl::encoding::Context) -> usize {
22261            16
22262        }
22263    }
22264
22265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateMuted, D>
22266        for &UsageStateMuted
22267    {
22268        unsafe fn encode(
22269            self,
22270            encoder: &mut fidl::encoding::Encoder<'_, D>,
22271            offset: usize,
22272            mut depth: fidl::encoding::Depth,
22273        ) -> fidl::Result<()> {
22274            encoder.debug_check_bounds::<UsageStateMuted>(offset);
22275            // Vector header
22276            let max_ordinal: u64 = self.max_ordinal_present();
22277            encoder.write_num(max_ordinal, offset);
22278            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22279            // Calling encoder.out_of_line_offset(0) is not allowed.
22280            if max_ordinal == 0 {
22281                return Ok(());
22282            }
22283            depth.increment()?;
22284            let envelope_size = 8;
22285            let bytes_len = max_ordinal as usize * envelope_size;
22286            #[allow(unused_variables)]
22287            let offset = encoder.out_of_line_offset(bytes_len);
22288            let mut _prev_end_offset: usize = 0;
22289
22290            Ok(())
22291        }
22292    }
22293
22294    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateMuted {
22295        #[inline(always)]
22296        fn new_empty() -> Self {
22297            Self::default()
22298        }
22299
22300        unsafe fn decode(
22301            &mut self,
22302            decoder: &mut fidl::encoding::Decoder<'_, D>,
22303            offset: usize,
22304            mut depth: fidl::encoding::Depth,
22305        ) -> fidl::Result<()> {
22306            decoder.debug_check_bounds::<Self>(offset);
22307            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22308                None => return Err(fidl::Error::NotNullable),
22309                Some(len) => len,
22310            };
22311            // Calling decoder.out_of_line_offset(0) is not allowed.
22312            if len == 0 {
22313                return Ok(());
22314            };
22315            depth.increment()?;
22316            let envelope_size = 8;
22317            let bytes_len = len * envelope_size;
22318            let offset = decoder.out_of_line_offset(bytes_len)?;
22319            // Decode the envelope for each type.
22320            let mut _next_ordinal_to_read = 0;
22321            let mut next_offset = offset;
22322            let end_offset = offset + bytes_len;
22323
22324            // Decode the remaining unknown envelopes.
22325            while next_offset < end_offset {
22326                _next_ordinal_to_read += 1;
22327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22328                next_offset += envelope_size;
22329            }
22330
22331            Ok(())
22332        }
22333    }
22334
22335    impl UsageStateUnadjusted {
22336        #[inline(always)]
22337        fn max_ordinal_present(&self) -> u64 {
22338            0
22339        }
22340    }
22341
22342    impl fidl::encoding::ValueTypeMarker for UsageStateUnadjusted {
22343        type Borrowed<'a> = &'a Self;
22344        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22345            value
22346        }
22347    }
22348
22349    unsafe impl fidl::encoding::TypeMarker for UsageStateUnadjusted {
22350        type Owned = Self;
22351
22352        #[inline(always)]
22353        fn inline_align(_context: fidl::encoding::Context) -> usize {
22354            8
22355        }
22356
22357        #[inline(always)]
22358        fn inline_size(_context: fidl::encoding::Context) -> usize {
22359            16
22360        }
22361    }
22362
22363    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageStateUnadjusted, D>
22364        for &UsageStateUnadjusted
22365    {
22366        unsafe fn encode(
22367            self,
22368            encoder: &mut fidl::encoding::Encoder<'_, D>,
22369            offset: usize,
22370            mut depth: fidl::encoding::Depth,
22371        ) -> fidl::Result<()> {
22372            encoder.debug_check_bounds::<UsageStateUnadjusted>(offset);
22373            // Vector header
22374            let max_ordinal: u64 = self.max_ordinal_present();
22375            encoder.write_num(max_ordinal, offset);
22376            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22377            // Calling encoder.out_of_line_offset(0) is not allowed.
22378            if max_ordinal == 0 {
22379                return Ok(());
22380            }
22381            depth.increment()?;
22382            let envelope_size = 8;
22383            let bytes_len = max_ordinal as usize * envelope_size;
22384            #[allow(unused_variables)]
22385            let offset = encoder.out_of_line_offset(bytes_len);
22386            let mut _prev_end_offset: usize = 0;
22387
22388            Ok(())
22389        }
22390    }
22391
22392    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageStateUnadjusted {
22393        #[inline(always)]
22394        fn new_empty() -> Self {
22395            Self::default()
22396        }
22397
22398        unsafe fn decode(
22399            &mut self,
22400            decoder: &mut fidl::encoding::Decoder<'_, D>,
22401            offset: usize,
22402            mut depth: fidl::encoding::Depth,
22403        ) -> fidl::Result<()> {
22404            decoder.debug_check_bounds::<Self>(offset);
22405            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22406                None => return Err(fidl::Error::NotNullable),
22407                Some(len) => len,
22408            };
22409            // Calling decoder.out_of_line_offset(0) is not allowed.
22410            if len == 0 {
22411                return Ok(());
22412            };
22413            depth.increment()?;
22414            let envelope_size = 8;
22415            let bytes_len = len * envelope_size;
22416            let offset = decoder.out_of_line_offset(bytes_len)?;
22417            // Decode the envelope for each type.
22418            let mut _next_ordinal_to_read = 0;
22419            let mut next_offset = offset;
22420            let end_offset = offset + bytes_len;
22421
22422            // Decode the remaining unknown envelopes.
22423            while next_offset < end_offset {
22424                _next_ordinal_to_read += 1;
22425                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22426                next_offset += envelope_size;
22427            }
22428
22429            Ok(())
22430        }
22431    }
22432
22433    impl fidl::encoding::ValueTypeMarker for AacBitRate {
22434        type Borrowed<'a> = &'a Self;
22435        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22436            value
22437        }
22438    }
22439
22440    unsafe impl fidl::encoding::TypeMarker for AacBitRate {
22441        type Owned = Self;
22442
22443        #[inline(always)]
22444        fn inline_align(_context: fidl::encoding::Context) -> usize {
22445            8
22446        }
22447
22448        #[inline(always)]
22449        fn inline_size(_context: fidl::encoding::Context) -> usize {
22450            16
22451        }
22452    }
22453
22454    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacBitRate, D>
22455        for &AacBitRate
22456    {
22457        #[inline]
22458        unsafe fn encode(
22459            self,
22460            encoder: &mut fidl::encoding::Encoder<'_, D>,
22461            offset: usize,
22462            _depth: fidl::encoding::Depth,
22463        ) -> fidl::Result<()> {
22464            encoder.debug_check_bounds::<AacBitRate>(offset);
22465            encoder.write_num::<u64>(self.ordinal(), offset);
22466            match self {
22467                AacBitRate::Constant(ref val) => {
22468                    fidl::encoding::encode_in_envelope::<AacConstantBitRate, D>(
22469                        <AacConstantBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22470                        encoder,
22471                        offset + 8,
22472                        _depth,
22473                    )
22474                }
22475                AacBitRate::Variable(ref val) => {
22476                    fidl::encoding::encode_in_envelope::<AacVariableBitRate, D>(
22477                        <AacVariableBitRate as fidl::encoding::ValueTypeMarker>::borrow(val),
22478                        encoder,
22479                        offset + 8,
22480                        _depth,
22481                    )
22482                }
22483            }
22484        }
22485    }
22486
22487    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacBitRate {
22488        #[inline(always)]
22489        fn new_empty() -> Self {
22490            Self::Constant(fidl::new_empty!(AacConstantBitRate, D))
22491        }
22492
22493        #[inline]
22494        unsafe fn decode(
22495            &mut self,
22496            decoder: &mut fidl::encoding::Decoder<'_, D>,
22497            offset: usize,
22498            mut depth: fidl::encoding::Depth,
22499        ) -> fidl::Result<()> {
22500            decoder.debug_check_bounds::<Self>(offset);
22501            #[allow(unused_variables)]
22502            let next_out_of_line = decoder.next_out_of_line();
22503            let handles_before = decoder.remaining_handles();
22504            let (ordinal, inlined, num_bytes, num_handles) =
22505                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22506
22507            let member_inline_size = match ordinal {
22508                1 => {
22509                    <AacConstantBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22510                }
22511                2 => {
22512                    <AacVariableBitRate as fidl::encoding::TypeMarker>::inline_size(decoder.context)
22513                }
22514                _ => return Err(fidl::Error::UnknownUnionTag),
22515            };
22516
22517            if inlined != (member_inline_size <= 4) {
22518                return Err(fidl::Error::InvalidInlineBitInEnvelope);
22519            }
22520            let _inner_offset;
22521            if inlined {
22522                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22523                _inner_offset = offset + 8;
22524            } else {
22525                depth.increment()?;
22526                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22527            }
22528            match ordinal {
22529                1 => {
22530                    #[allow(irrefutable_let_patterns)]
22531                    if let AacBitRate::Constant(_) = self {
22532                        // Do nothing, read the value into the object
22533                    } else {
22534                        // Initialize `self` to the right variant
22535                        *self = AacBitRate::Constant(fidl::new_empty!(AacConstantBitRate, D));
22536                    }
22537                    #[allow(irrefutable_let_patterns)]
22538                    if let AacBitRate::Constant(ref mut val) = self {
22539                        fidl::decode!(AacConstantBitRate, D, val, decoder, _inner_offset, depth)?;
22540                    } else {
22541                        unreachable!()
22542                    }
22543                }
22544                2 => {
22545                    #[allow(irrefutable_let_patterns)]
22546                    if let AacBitRate::Variable(_) = self {
22547                        // Do nothing, read the value into the object
22548                    } else {
22549                        // Initialize `self` to the right variant
22550                        *self = AacBitRate::Variable(fidl::new_empty!(AacVariableBitRate, D));
22551                    }
22552                    #[allow(irrefutable_let_patterns)]
22553                    if let AacBitRate::Variable(ref mut val) = self {
22554                        fidl::decode!(AacVariableBitRate, D, val, decoder, _inner_offset, depth)?;
22555                    } else {
22556                        unreachable!()
22557                    }
22558                }
22559                ordinal => panic!("unexpected ordinal {:?}", ordinal),
22560            }
22561            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22562                return Err(fidl::Error::InvalidNumBytesInEnvelope);
22563            }
22564            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22565                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22566            }
22567            Ok(())
22568        }
22569    }
22570
22571    impl fidl::encoding::ValueTypeMarker for AacTransport {
22572        type Borrowed<'a> = &'a Self;
22573        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22574            value
22575        }
22576    }
22577
22578    unsafe impl fidl::encoding::TypeMarker for AacTransport {
22579        type Owned = Self;
22580
22581        #[inline(always)]
22582        fn inline_align(_context: fidl::encoding::Context) -> usize {
22583            8
22584        }
22585
22586        #[inline(always)]
22587        fn inline_size(_context: fidl::encoding::Context) -> usize {
22588            16
22589        }
22590    }
22591
22592    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AacTransport, D>
22593        for &AacTransport
22594    {
22595        #[inline]
22596        unsafe fn encode(
22597            self,
22598            encoder: &mut fidl::encoding::Encoder<'_, D>,
22599            offset: usize,
22600            _depth: fidl::encoding::Depth,
22601        ) -> fidl::Result<()> {
22602            encoder.debug_check_bounds::<AacTransport>(offset);
22603            encoder.write_num::<u64>(self.ordinal(), offset);
22604            match self {
22605                AacTransport::Raw(ref val) => {
22606                    fidl::encoding::encode_in_envelope::<AacTransportRaw, D>(
22607                        <AacTransportRaw as fidl::encoding::ValueTypeMarker>::borrow(val),
22608                        encoder,
22609                        offset + 8,
22610                        _depth,
22611                    )
22612                }
22613                AacTransport::Latm(ref val) => {
22614                    fidl::encoding::encode_in_envelope::<AacTransportLatm, D>(
22615                        <AacTransportLatm as fidl::encoding::ValueTypeMarker>::borrow(val),
22616                        encoder,
22617                        offset + 8,
22618                        _depth,
22619                    )
22620                }
22621                AacTransport::Adts(ref val) => {
22622                    fidl::encoding::encode_in_envelope::<AacTransportAdts, D>(
22623                        <AacTransportAdts as fidl::encoding::ValueTypeMarker>::borrow(val),
22624                        encoder,
22625                        offset + 8,
22626                        _depth,
22627                    )
22628                }
22629                AacTransport::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22630            }
22631        }
22632    }
22633
22634    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AacTransport {
22635        #[inline(always)]
22636        fn new_empty() -> Self {
22637            Self::__SourceBreaking { unknown_ordinal: 0 }
22638        }
22639
22640        #[inline]
22641        unsafe fn decode(
22642            &mut self,
22643            decoder: &mut fidl::encoding::Decoder<'_, D>,
22644            offset: usize,
22645            mut depth: fidl::encoding::Depth,
22646        ) -> fidl::Result<()> {
22647            decoder.debug_check_bounds::<Self>(offset);
22648            #[allow(unused_variables)]
22649            let next_out_of_line = decoder.next_out_of_line();
22650            let handles_before = decoder.remaining_handles();
22651            let (ordinal, inlined, num_bytes, num_handles) =
22652                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22653
22654            let member_inline_size = match ordinal {
22655                1 => <AacTransportRaw as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22656                2 => <AacTransportLatm as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22657                3 => <AacTransportAdts as fidl::encoding::TypeMarker>::inline_size(decoder.context),
22658                0 => return Err(fidl::Error::UnknownUnionTag),
22659                _ => num_bytes as usize,
22660            };
22661
22662            if inlined != (member_inline_size <= 4) {
22663                return Err(fidl::Error::InvalidInlineBitInEnvelope);
22664            }
22665            let _inner_offset;
22666            if inlined {
22667                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22668                _inner_offset = offset + 8;
22669            } else {
22670                depth.increment()?;
22671                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22672            }
22673            match ordinal {
22674                1 => {
22675                    #[allow(irrefutable_let_patterns)]
22676                    if let AacTransport::Raw(_) = self {
22677                        // Do nothing, read the value into the object
22678                    } else {
22679                        // Initialize `self` to the right variant
22680                        *self = AacTransport::Raw(fidl::new_empty!(AacTransportRaw, D));
22681                    }
22682                    #[allow(irrefutable_let_patterns)]
22683                    if let AacTransport::Raw(ref mut val) = self {
22684                        fidl::decode!(AacTransportRaw, D, val, decoder, _inner_offset, depth)?;
22685                    } else {
22686                        unreachable!()
22687                    }
22688                }
22689                2 => {
22690                    #[allow(irrefutable_let_patterns)]
22691                    if let AacTransport::Latm(_) = self {
22692                        // Do nothing, read the value into the object
22693                    } else {
22694                        // Initialize `self` to the right variant
22695                        *self = AacTransport::Latm(fidl::new_empty!(AacTransportLatm, D));
22696                    }
22697                    #[allow(irrefutable_let_patterns)]
22698                    if let AacTransport::Latm(ref mut val) = self {
22699                        fidl::decode!(AacTransportLatm, D, val, decoder, _inner_offset, depth)?;
22700                    } else {
22701                        unreachable!()
22702                    }
22703                }
22704                3 => {
22705                    #[allow(irrefutable_let_patterns)]
22706                    if let AacTransport::Adts(_) = self {
22707                        // Do nothing, read the value into the object
22708                    } else {
22709                        // Initialize `self` to the right variant
22710                        *self = AacTransport::Adts(fidl::new_empty!(AacTransportAdts, D));
22711                    }
22712                    #[allow(irrefutable_let_patterns)]
22713                    if let AacTransport::Adts(ref mut val) = self {
22714                        fidl::decode!(AacTransportAdts, D, val, decoder, _inner_offset, depth)?;
22715                    } else {
22716                        unreachable!()
22717                    }
22718                }
22719                #[allow(deprecated)]
22720                ordinal => {
22721                    for _ in 0..num_handles {
22722                        decoder.drop_next_handle()?;
22723                    }
22724                    *self = AacTransport::__SourceBreaking { unknown_ordinal: ordinal };
22725                }
22726            }
22727            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22728                return Err(fidl::Error::InvalidNumBytesInEnvelope);
22729            }
22730            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22731                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22732            }
22733            Ok(())
22734        }
22735    }
22736
22737    impl fidl::encoding::ValueTypeMarker for AudioCapturerConfiguration {
22738        type Borrowed<'a> = &'a Self;
22739        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22740            value
22741        }
22742    }
22743
22744    unsafe impl fidl::encoding::TypeMarker for AudioCapturerConfiguration {
22745        type Owned = Self;
22746
22747        #[inline(always)]
22748        fn inline_align(_context: fidl::encoding::Context) -> usize {
22749            8
22750        }
22751
22752        #[inline(always)]
22753        fn inline_size(_context: fidl::encoding::Context) -> usize {
22754            16
22755        }
22756    }
22757
22758    unsafe impl<D: fidl::encoding::ResourceDialect>
22759        fidl::encoding::Encode<AudioCapturerConfiguration, D> for &AudioCapturerConfiguration
22760    {
22761        #[inline]
22762        unsafe fn encode(
22763            self,
22764            encoder: &mut fidl::encoding::Encoder<'_, D>,
22765            offset: usize,
22766            _depth: fidl::encoding::Depth,
22767        ) -> fidl::Result<()> {
22768            encoder.debug_check_bounds::<AudioCapturerConfiguration>(offset);
22769            encoder.write_num::<u64>(self.ordinal(), offset);
22770            match self {
22771                AudioCapturerConfiguration::Loopback(ref val) => fidl::encoding::encode_in_envelope::<
22772                    LoopbackAudioCapturerConfiguration,
22773                    D,
22774                >(
22775                    <LoopbackAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22776                        val,
22777                    ),
22778                    encoder,
22779                    offset + 8,
22780                    _depth,
22781                ),
22782                AudioCapturerConfiguration::Input(ref val) => fidl::encoding::encode_in_envelope::<
22783                    InputAudioCapturerConfiguration,
22784                    D,
22785                >(
22786                    <InputAudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(
22787                        val,
22788                    ),
22789                    encoder,
22790                    offset + 8,
22791                    _depth,
22792                ),
22793            }
22794        }
22795    }
22796
22797    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
22798        for AudioCapturerConfiguration
22799    {
22800        #[inline(always)]
22801        fn new_empty() -> Self {
22802            Self::Loopback(fidl::new_empty!(LoopbackAudioCapturerConfiguration, D))
22803        }
22804
22805        #[inline]
22806        unsafe fn decode(
22807            &mut self,
22808            decoder: &mut fidl::encoding::Decoder<'_, D>,
22809            offset: usize,
22810            mut depth: fidl::encoding::Depth,
22811        ) -> fidl::Result<()> {
22812            decoder.debug_check_bounds::<Self>(offset);
22813            #[allow(unused_variables)]
22814            let next_out_of_line = decoder.next_out_of_line();
22815            let handles_before = decoder.remaining_handles();
22816            let (ordinal, inlined, num_bytes, num_handles) =
22817                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22818
22819            let member_inline_size = match ordinal {
22820                1 => {
22821                    <LoopbackAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22822                        decoder.context,
22823                    )
22824                }
22825                2 => <InputAudioCapturerConfiguration as fidl::encoding::TypeMarker>::inline_size(
22826                    decoder.context,
22827                ),
22828                _ => return Err(fidl::Error::UnknownUnionTag),
22829            };
22830
22831            if inlined != (member_inline_size <= 4) {
22832                return Err(fidl::Error::InvalidInlineBitInEnvelope);
22833            }
22834            let _inner_offset;
22835            if inlined {
22836                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
22837                _inner_offset = offset + 8;
22838            } else {
22839                depth.increment()?;
22840                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22841            }
22842            match ordinal {
22843                1 => {
22844                    #[allow(irrefutable_let_patterns)]
22845                    if let AudioCapturerConfiguration::Loopback(_) = self {
22846                        // Do nothing, read the value into the object
22847                    } else {
22848                        // Initialize `self` to the right variant
22849                        *self = AudioCapturerConfiguration::Loopback(fidl::new_empty!(
22850                            LoopbackAudioCapturerConfiguration,
22851                            D
22852                        ));
22853                    }
22854                    #[allow(irrefutable_let_patterns)]
22855                    if let AudioCapturerConfiguration::Loopback(ref mut val) = self {
22856                        fidl::decode!(
22857                            LoopbackAudioCapturerConfiguration,
22858                            D,
22859                            val,
22860                            decoder,
22861                            _inner_offset,
22862                            depth
22863                        )?;
22864                    } else {
22865                        unreachable!()
22866                    }
22867                }
22868                2 => {
22869                    #[allow(irrefutable_let_patterns)]
22870                    if let AudioCapturerConfiguration::Input(_) = self {
22871                        // Do nothing, read the value into the object
22872                    } else {
22873                        // Initialize `self` to the right variant
22874                        *self = AudioCapturerConfiguration::Input(fidl::new_empty!(
22875                            InputAudioCapturerConfiguration,
22876                            D
22877                        ));
22878                    }
22879                    #[allow(irrefutable_let_patterns)]
22880                    if let AudioCapturerConfiguration::Input(ref mut val) = self {
22881                        fidl::decode!(
22882                            InputAudioCapturerConfiguration,
22883                            D,
22884                            val,
22885                            decoder,
22886                            _inner_offset,
22887                            depth
22888                        )?;
22889                    } else {
22890                        unreachable!()
22891                    }
22892                }
22893                ordinal => panic!("unexpected ordinal {:?}", ordinal),
22894            }
22895            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
22896                return Err(fidl::Error::InvalidNumBytesInEnvelope);
22897            }
22898            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22899                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22900            }
22901            Ok(())
22902        }
22903    }
22904
22905    impl fidl::encoding::ValueTypeMarker for AudioCompressedFormat {
22906        type Borrowed<'a> = &'a Self;
22907        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22908            value
22909        }
22910    }
22911
22912    unsafe impl fidl::encoding::TypeMarker for AudioCompressedFormat {
22913        type Owned = Self;
22914
22915        #[inline(always)]
22916        fn inline_align(_context: fidl::encoding::Context) -> usize {
22917            8
22918        }
22919
22920        #[inline(always)]
22921        fn inline_size(_context: fidl::encoding::Context) -> usize {
22922            16
22923        }
22924    }
22925
22926    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioCompressedFormat, D>
22927        for &AudioCompressedFormat
22928    {
22929        #[inline]
22930        unsafe fn encode(
22931            self,
22932            encoder: &mut fidl::encoding::Encoder<'_, D>,
22933            offset: usize,
22934            _depth: fidl::encoding::Depth,
22935        ) -> fidl::Result<()> {
22936            encoder.debug_check_bounds::<AudioCompressedFormat>(offset);
22937            encoder.write_num::<u64>(self.ordinal(), offset);
22938            match self {
22939                AudioCompressedFormat::Aac(ref val) => {
22940                    fidl::encoding::encode_in_envelope::<AudioCompressedFormatAac, D>(
22941                        <AudioCompressedFormatAac as fidl::encoding::ValueTypeMarker>::borrow(val),
22942                        encoder,
22943                        offset + 8,
22944                        _depth,
22945                    )
22946                }
22947                AudioCompressedFormat::Sbc(ref val) => {
22948                    fidl::encoding::encode_in_envelope::<AudioCompressedFormatSbc, D>(
22949                        <AudioCompressedFormatSbc as fidl::encoding::ValueTypeMarker>::borrow(val),
22950                        encoder,
22951                        offset + 8,
22952                        _depth,
22953                    )
22954                }
22955                AudioCompressedFormat::Cvsd(ref val) => {
22956                    fidl::encoding::encode_in_envelope::<AudioCompressedFormatCvsd, D>(
22957                        <AudioCompressedFormatCvsd as fidl::encoding::ValueTypeMarker>::borrow(val),
22958                        encoder,
22959                        offset + 8,
22960                        _depth,
22961                    )
22962                }
22963                AudioCompressedFormat::Lc3(ref val) => {
22964                    fidl::encoding::encode_in_envelope::<AudioCompressedFormatLc3, D>(
22965                        <AudioCompressedFormatLc3 as fidl::encoding::ValueTypeMarker>::borrow(val),
22966                        encoder,
22967                        offset + 8,
22968                        _depth,
22969                    )
22970                }
22971                AudioCompressedFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
22972            }
22973        }
22974    }
22975
22976    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioCompressedFormat {
22977        #[inline(always)]
22978        fn new_empty() -> Self {
22979            Self::__SourceBreaking { unknown_ordinal: 0 }
22980        }
22981
22982        #[inline]
22983        unsafe fn decode(
22984            &mut self,
22985            decoder: &mut fidl::encoding::Decoder<'_, D>,
22986            offset: usize,
22987            mut depth: fidl::encoding::Depth,
22988        ) -> fidl::Result<()> {
22989            decoder.debug_check_bounds::<Self>(offset);
22990            #[allow(unused_variables)]
22991            let next_out_of_line = decoder.next_out_of_line();
22992            let handles_before = decoder.remaining_handles();
22993            let (ordinal, inlined, num_bytes, num_handles) =
22994                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
22995
22996            let member_inline_size = match ordinal {
22997                1 => <AudioCompressedFormatAac as fidl::encoding::TypeMarker>::inline_size(
22998                    decoder.context,
22999                ),
23000                2 => <AudioCompressedFormatSbc as fidl::encoding::TypeMarker>::inline_size(
23001                    decoder.context,
23002                ),
23003                3 => <AudioCompressedFormatCvsd as fidl::encoding::TypeMarker>::inline_size(
23004                    decoder.context,
23005                ),
23006                4 => <AudioCompressedFormatLc3 as fidl::encoding::TypeMarker>::inline_size(
23007                    decoder.context,
23008                ),
23009                0 => return Err(fidl::Error::UnknownUnionTag),
23010                _ => num_bytes as usize,
23011            };
23012
23013            if inlined != (member_inline_size <= 4) {
23014                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23015            }
23016            let _inner_offset;
23017            if inlined {
23018                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23019                _inner_offset = offset + 8;
23020            } else {
23021                depth.increment()?;
23022                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23023            }
23024            match ordinal {
23025                1 => {
23026                    #[allow(irrefutable_let_patterns)]
23027                    if let AudioCompressedFormat::Aac(_) = self {
23028                        // Do nothing, read the value into the object
23029                    } else {
23030                        // Initialize `self` to the right variant
23031                        *self = AudioCompressedFormat::Aac(fidl::new_empty!(
23032                            AudioCompressedFormatAac,
23033                            D
23034                        ));
23035                    }
23036                    #[allow(irrefutable_let_patterns)]
23037                    if let AudioCompressedFormat::Aac(ref mut val) = self {
23038                        fidl::decode!(
23039                            AudioCompressedFormatAac,
23040                            D,
23041                            val,
23042                            decoder,
23043                            _inner_offset,
23044                            depth
23045                        )?;
23046                    } else {
23047                        unreachable!()
23048                    }
23049                }
23050                2 => {
23051                    #[allow(irrefutable_let_patterns)]
23052                    if let AudioCompressedFormat::Sbc(_) = self {
23053                        // Do nothing, read the value into the object
23054                    } else {
23055                        // Initialize `self` to the right variant
23056                        *self = AudioCompressedFormat::Sbc(fidl::new_empty!(
23057                            AudioCompressedFormatSbc,
23058                            D
23059                        ));
23060                    }
23061                    #[allow(irrefutable_let_patterns)]
23062                    if let AudioCompressedFormat::Sbc(ref mut val) = self {
23063                        fidl::decode!(
23064                            AudioCompressedFormatSbc,
23065                            D,
23066                            val,
23067                            decoder,
23068                            _inner_offset,
23069                            depth
23070                        )?;
23071                    } else {
23072                        unreachable!()
23073                    }
23074                }
23075                3 => {
23076                    #[allow(irrefutable_let_patterns)]
23077                    if let AudioCompressedFormat::Cvsd(_) = self {
23078                        // Do nothing, read the value into the object
23079                    } else {
23080                        // Initialize `self` to the right variant
23081                        *self = AudioCompressedFormat::Cvsd(fidl::new_empty!(
23082                            AudioCompressedFormatCvsd,
23083                            D
23084                        ));
23085                    }
23086                    #[allow(irrefutable_let_patterns)]
23087                    if let AudioCompressedFormat::Cvsd(ref mut val) = self {
23088                        fidl::decode!(
23089                            AudioCompressedFormatCvsd,
23090                            D,
23091                            val,
23092                            decoder,
23093                            _inner_offset,
23094                            depth
23095                        )?;
23096                    } else {
23097                        unreachable!()
23098                    }
23099                }
23100                4 => {
23101                    #[allow(irrefutable_let_patterns)]
23102                    if let AudioCompressedFormat::Lc3(_) = self {
23103                        // Do nothing, read the value into the object
23104                    } else {
23105                        // Initialize `self` to the right variant
23106                        *self = AudioCompressedFormat::Lc3(fidl::new_empty!(
23107                            AudioCompressedFormatLc3,
23108                            D
23109                        ));
23110                    }
23111                    #[allow(irrefutable_let_patterns)]
23112                    if let AudioCompressedFormat::Lc3(ref mut val) = self {
23113                        fidl::decode!(
23114                            AudioCompressedFormatLc3,
23115                            D,
23116                            val,
23117                            decoder,
23118                            _inner_offset,
23119                            depth
23120                        )?;
23121                    } else {
23122                        unreachable!()
23123                    }
23124                }
23125                #[allow(deprecated)]
23126                ordinal => {
23127                    for _ in 0..num_handles {
23128                        decoder.drop_next_handle()?;
23129                    }
23130                    *self = AudioCompressedFormat::__SourceBreaking { unknown_ordinal: ordinal };
23131                }
23132            }
23133            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23134                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23135            }
23136            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23137                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23138            }
23139            Ok(())
23140        }
23141    }
23142
23143    impl fidl::encoding::ValueTypeMarker for AudioConsumerError {
23144        type Borrowed<'a> = &'a Self;
23145        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23146            value
23147        }
23148    }
23149
23150    unsafe impl fidl::encoding::TypeMarker for AudioConsumerError {
23151        type Owned = Self;
23152
23153        #[inline(always)]
23154        fn inline_align(_context: fidl::encoding::Context) -> usize {
23155            8
23156        }
23157
23158        #[inline(always)]
23159        fn inline_size(_context: fidl::encoding::Context) -> usize {
23160            16
23161        }
23162    }
23163
23164    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioConsumerError, D>
23165        for &AudioConsumerError
23166    {
23167        #[inline]
23168        unsafe fn encode(
23169            self,
23170            encoder: &mut fidl::encoding::Encoder<'_, D>,
23171            offset: usize,
23172            _depth: fidl::encoding::Depth,
23173        ) -> fidl::Result<()> {
23174            encoder.debug_check_bounds::<AudioConsumerError>(offset);
23175            encoder.write_num::<u64>(self.ordinal(), offset);
23176            match self {
23177                AudioConsumerError::PlaceHolder(ref val) => {
23178                    fidl::encoding::encode_in_envelope::<Void, D>(
23179                        <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
23180                        encoder,
23181                        offset + 8,
23182                        _depth,
23183                    )
23184                }
23185            }
23186        }
23187    }
23188
23189    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioConsumerError {
23190        #[inline(always)]
23191        fn new_empty() -> Self {
23192            Self::PlaceHolder(fidl::new_empty!(Void, D))
23193        }
23194
23195        #[inline]
23196        unsafe fn decode(
23197            &mut self,
23198            decoder: &mut fidl::encoding::Decoder<'_, D>,
23199            offset: usize,
23200            mut depth: fidl::encoding::Depth,
23201        ) -> fidl::Result<()> {
23202            decoder.debug_check_bounds::<Self>(offset);
23203            #[allow(unused_variables)]
23204            let next_out_of_line = decoder.next_out_of_line();
23205            let handles_before = decoder.remaining_handles();
23206            let (ordinal, inlined, num_bytes, num_handles) =
23207                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23208
23209            let member_inline_size = match ordinal {
23210                1 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23211                _ => return Err(fidl::Error::UnknownUnionTag),
23212            };
23213
23214            if inlined != (member_inline_size <= 4) {
23215                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23216            }
23217            let _inner_offset;
23218            if inlined {
23219                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23220                _inner_offset = offset + 8;
23221            } else {
23222                depth.increment()?;
23223                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23224            }
23225            match ordinal {
23226                1 => {
23227                    #[allow(irrefutable_let_patterns)]
23228                    if let AudioConsumerError::PlaceHolder(_) = self {
23229                        // Do nothing, read the value into the object
23230                    } else {
23231                        // Initialize `self` to the right variant
23232                        *self = AudioConsumerError::PlaceHolder(fidl::new_empty!(Void, D));
23233                    }
23234                    #[allow(irrefutable_let_patterns)]
23235                    if let AudioConsumerError::PlaceHolder(ref mut val) = self {
23236                        fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
23237                    } else {
23238                        unreachable!()
23239                    }
23240                }
23241                ordinal => panic!("unexpected ordinal {:?}", ordinal),
23242            }
23243            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23244                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23245            }
23246            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23247                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23248            }
23249            Ok(())
23250        }
23251    }
23252
23253    impl fidl::encoding::ValueTypeMarker for AudioFormat {
23254        type Borrowed<'a> = &'a Self;
23255        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23256            value
23257        }
23258    }
23259
23260    unsafe impl fidl::encoding::TypeMarker for AudioFormat {
23261        type Owned = Self;
23262
23263        #[inline(always)]
23264        fn inline_align(_context: fidl::encoding::Context) -> usize {
23265            8
23266        }
23267
23268        #[inline(always)]
23269        fn inline_size(_context: fidl::encoding::Context) -> usize {
23270            16
23271        }
23272    }
23273
23274    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioFormat, D>
23275        for &AudioFormat
23276    {
23277        #[inline]
23278        unsafe fn encode(
23279            self,
23280            encoder: &mut fidl::encoding::Encoder<'_, D>,
23281            offset: usize,
23282            _depth: fidl::encoding::Depth,
23283        ) -> fidl::Result<()> {
23284            encoder.debug_check_bounds::<AudioFormat>(offset);
23285            encoder.write_num::<u64>(self.ordinal(), offset);
23286            match self {
23287                AudioFormat::Compressed(ref val) => {
23288                    fidl::encoding::encode_in_envelope::<AudioCompressedFormat, D>(
23289                        <AudioCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23290                        encoder,
23291                        offset + 8,
23292                        _depth,
23293                    )
23294                }
23295                AudioFormat::Uncompressed(ref val) => {
23296                    fidl::encoding::encode_in_envelope::<AudioUncompressedFormat, D>(
23297                        <AudioUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23298                        encoder,
23299                        offset + 8,
23300                        _depth,
23301                    )
23302                }
23303            }
23304        }
23305    }
23306
23307    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioFormat {
23308        #[inline(always)]
23309        fn new_empty() -> Self {
23310            Self::Compressed(fidl::new_empty!(AudioCompressedFormat, D))
23311        }
23312
23313        #[inline]
23314        unsafe fn decode(
23315            &mut self,
23316            decoder: &mut fidl::encoding::Decoder<'_, D>,
23317            offset: usize,
23318            mut depth: fidl::encoding::Depth,
23319        ) -> fidl::Result<()> {
23320            decoder.debug_check_bounds::<Self>(offset);
23321            #[allow(unused_variables)]
23322            let next_out_of_line = decoder.next_out_of_line();
23323            let handles_before = decoder.remaining_handles();
23324            let (ordinal, inlined, num_bytes, num_handles) =
23325                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23326
23327            let member_inline_size = match ordinal {
23328                1 => <AudioCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23329                    decoder.context,
23330                ),
23331                2 => <AudioUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
23332                    decoder.context,
23333                ),
23334                _ => return Err(fidl::Error::UnknownUnionTag),
23335            };
23336
23337            if inlined != (member_inline_size <= 4) {
23338                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23339            }
23340            let _inner_offset;
23341            if inlined {
23342                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23343                _inner_offset = offset + 8;
23344            } else {
23345                depth.increment()?;
23346                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23347            }
23348            match ordinal {
23349                1 => {
23350                    #[allow(irrefutable_let_patterns)]
23351                    if let AudioFormat::Compressed(_) = self {
23352                        // Do nothing, read the value into the object
23353                    } else {
23354                        // Initialize `self` to the right variant
23355                        *self = AudioFormat::Compressed(fidl::new_empty!(AudioCompressedFormat, D));
23356                    }
23357                    #[allow(irrefutable_let_patterns)]
23358                    if let AudioFormat::Compressed(ref mut val) = self {
23359                        fidl::decode!(
23360                            AudioCompressedFormat,
23361                            D,
23362                            val,
23363                            decoder,
23364                            _inner_offset,
23365                            depth
23366                        )?;
23367                    } else {
23368                        unreachable!()
23369                    }
23370                }
23371                2 => {
23372                    #[allow(irrefutable_let_patterns)]
23373                    if let AudioFormat::Uncompressed(_) = self {
23374                        // Do nothing, read the value into the object
23375                    } else {
23376                        // Initialize `self` to the right variant
23377                        *self =
23378                            AudioFormat::Uncompressed(fidl::new_empty!(AudioUncompressedFormat, D));
23379                    }
23380                    #[allow(irrefutable_let_patterns)]
23381                    if let AudioFormat::Uncompressed(ref mut val) = self {
23382                        fidl::decode!(
23383                            AudioUncompressedFormat,
23384                            D,
23385                            val,
23386                            decoder,
23387                            _inner_offset,
23388                            depth
23389                        )?;
23390                    } else {
23391                        unreachable!()
23392                    }
23393                }
23394                ordinal => panic!("unexpected ordinal {:?}", ordinal),
23395            }
23396            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23397                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23398            }
23399            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23400                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23401            }
23402            Ok(())
23403        }
23404    }
23405
23406    impl fidl::encoding::ValueTypeMarker for AudioUncompressedFormat {
23407        type Borrowed<'a> = &'a Self;
23408        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23409            value
23410        }
23411    }
23412
23413    unsafe impl fidl::encoding::TypeMarker for AudioUncompressedFormat {
23414        type Owned = Self;
23415
23416        #[inline(always)]
23417        fn inline_align(_context: fidl::encoding::Context) -> usize {
23418            8
23419        }
23420
23421        #[inline(always)]
23422        fn inline_size(_context: fidl::encoding::Context) -> usize {
23423            16
23424        }
23425    }
23426
23427    unsafe impl<D: fidl::encoding::ResourceDialect>
23428        fidl::encoding::Encode<AudioUncompressedFormat, D> for &AudioUncompressedFormat
23429    {
23430        #[inline]
23431        unsafe fn encode(
23432            self,
23433            encoder: &mut fidl::encoding::Encoder<'_, D>,
23434            offset: usize,
23435            _depth: fidl::encoding::Depth,
23436        ) -> fidl::Result<()> {
23437            encoder.debug_check_bounds::<AudioUncompressedFormat>(offset);
23438            encoder.write_num::<u64>(self.ordinal(), offset);
23439            match self {
23440                AudioUncompressedFormat::Pcm(ref val) => {
23441                    fidl::encoding::encode_in_envelope::<PcmFormat, D>(
23442                        <PcmFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23443                        encoder,
23444                        offset + 8,
23445                        _depth,
23446                    )
23447                }
23448            }
23449        }
23450    }
23451
23452    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
23453        for AudioUncompressedFormat
23454    {
23455        #[inline(always)]
23456        fn new_empty() -> Self {
23457            Self::Pcm(fidl::new_empty!(PcmFormat, D))
23458        }
23459
23460        #[inline]
23461        unsafe fn decode(
23462            &mut self,
23463            decoder: &mut fidl::encoding::Decoder<'_, D>,
23464            offset: usize,
23465            mut depth: fidl::encoding::Depth,
23466        ) -> fidl::Result<()> {
23467            decoder.debug_check_bounds::<Self>(offset);
23468            #[allow(unused_variables)]
23469            let next_out_of_line = decoder.next_out_of_line();
23470            let handles_before = decoder.remaining_handles();
23471            let (ordinal, inlined, num_bytes, num_handles) =
23472                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23473
23474            let member_inline_size = match ordinal {
23475                1 => <PcmFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23476                _ => return Err(fidl::Error::UnknownUnionTag),
23477            };
23478
23479            if inlined != (member_inline_size <= 4) {
23480                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23481            }
23482            let _inner_offset;
23483            if inlined {
23484                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23485                _inner_offset = offset + 8;
23486            } else {
23487                depth.increment()?;
23488                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23489            }
23490            match ordinal {
23491                1 => {
23492                    #[allow(irrefutable_let_patterns)]
23493                    if let AudioUncompressedFormat::Pcm(_) = self {
23494                        // Do nothing, read the value into the object
23495                    } else {
23496                        // Initialize `self` to the right variant
23497                        *self = AudioUncompressedFormat::Pcm(fidl::new_empty!(PcmFormat, D));
23498                    }
23499                    #[allow(irrefutable_let_patterns)]
23500                    if let AudioUncompressedFormat::Pcm(ref mut val) = self {
23501                        fidl::decode!(PcmFormat, D, val, decoder, _inner_offset, depth)?;
23502                    } else {
23503                        unreachable!()
23504                    }
23505                }
23506                ordinal => panic!("unexpected ordinal {:?}", ordinal),
23507            }
23508            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23509                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23510            }
23511            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23512                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23513            }
23514            Ok(())
23515        }
23516    }
23517
23518    impl fidl::encoding::ValueTypeMarker for CryptoFormat {
23519        type Borrowed<'a> = &'a Self;
23520        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23521            value
23522        }
23523    }
23524
23525    unsafe impl fidl::encoding::TypeMarker for CryptoFormat {
23526        type Owned = Self;
23527
23528        #[inline(always)]
23529        fn inline_align(_context: fidl::encoding::Context) -> usize {
23530            8
23531        }
23532
23533        #[inline(always)]
23534        fn inline_size(_context: fidl::encoding::Context) -> usize {
23535            16
23536        }
23537    }
23538
23539    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CryptoFormat, D>
23540        for &CryptoFormat
23541    {
23542        #[inline]
23543        unsafe fn encode(
23544            self,
23545            encoder: &mut fidl::encoding::Encoder<'_, D>,
23546            offset: usize,
23547            _depth: fidl::encoding::Depth,
23548        ) -> fidl::Result<()> {
23549            encoder.debug_check_bounds::<CryptoFormat>(offset);
23550            encoder.write_num::<u64>(self.ordinal(), offset);
23551            match self {
23552                CryptoFormat::Encrypted(ref val) => {
23553                    fidl::encoding::encode_in_envelope::<EncryptedFormat, D>(
23554                        <EncryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23555                        encoder,
23556                        offset + 8,
23557                        _depth,
23558                    )
23559                }
23560                CryptoFormat::Decrypted(ref val) => {
23561                    fidl::encoding::encode_in_envelope::<DecryptedFormat, D>(
23562                        <DecryptedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23563                        encoder,
23564                        offset + 8,
23565                        _depth,
23566                    )
23567                }
23568                CryptoFormat::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23569            }
23570        }
23571    }
23572
23573    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CryptoFormat {
23574        #[inline(always)]
23575        fn new_empty() -> Self {
23576            Self::__SourceBreaking { unknown_ordinal: 0 }
23577        }
23578
23579        #[inline]
23580        unsafe fn decode(
23581            &mut self,
23582            decoder: &mut fidl::encoding::Decoder<'_, D>,
23583            offset: usize,
23584            mut depth: fidl::encoding::Depth,
23585        ) -> fidl::Result<()> {
23586            decoder.debug_check_bounds::<Self>(offset);
23587            #[allow(unused_variables)]
23588            let next_out_of_line = decoder.next_out_of_line();
23589            let handles_before = decoder.remaining_handles();
23590            let (ordinal, inlined, num_bytes, num_handles) =
23591                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23592
23593            let member_inline_size = match ordinal {
23594                1 => <EncryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23595                2 => <DecryptedFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23596                0 => return Err(fidl::Error::UnknownUnionTag),
23597                _ => num_bytes as usize,
23598            };
23599
23600            if inlined != (member_inline_size <= 4) {
23601                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23602            }
23603            let _inner_offset;
23604            if inlined {
23605                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23606                _inner_offset = offset + 8;
23607            } else {
23608                depth.increment()?;
23609                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23610            }
23611            match ordinal {
23612                1 => {
23613                    #[allow(irrefutable_let_patterns)]
23614                    if let CryptoFormat::Encrypted(_) = self {
23615                        // Do nothing, read the value into the object
23616                    } else {
23617                        // Initialize `self` to the right variant
23618                        *self = CryptoFormat::Encrypted(fidl::new_empty!(EncryptedFormat, D));
23619                    }
23620                    #[allow(irrefutable_let_patterns)]
23621                    if let CryptoFormat::Encrypted(ref mut val) = self {
23622                        fidl::decode!(EncryptedFormat, D, val, decoder, _inner_offset, depth)?;
23623                    } else {
23624                        unreachable!()
23625                    }
23626                }
23627                2 => {
23628                    #[allow(irrefutable_let_patterns)]
23629                    if let CryptoFormat::Decrypted(_) = self {
23630                        // Do nothing, read the value into the object
23631                    } else {
23632                        // Initialize `self` to the right variant
23633                        *self = CryptoFormat::Decrypted(fidl::new_empty!(DecryptedFormat, D));
23634                    }
23635                    #[allow(irrefutable_let_patterns)]
23636                    if let CryptoFormat::Decrypted(ref mut val) = self {
23637                        fidl::decode!(DecryptedFormat, D, val, decoder, _inner_offset, depth)?;
23638                    } else {
23639                        unreachable!()
23640                    }
23641                }
23642                #[allow(deprecated)]
23643                ordinal => {
23644                    for _ in 0..num_handles {
23645                        decoder.drop_next_handle()?;
23646                    }
23647                    *self = CryptoFormat::__SourceBreaking { unknown_ordinal: ordinal };
23648                }
23649            }
23650            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23651                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23652            }
23653            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23654                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23655            }
23656            Ok(())
23657        }
23658    }
23659
23660    impl fidl::encoding::ValueTypeMarker for DomainFormat {
23661        type Borrowed<'a> = &'a Self;
23662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23663            value
23664        }
23665    }
23666
23667    unsafe impl fidl::encoding::TypeMarker for DomainFormat {
23668        type Owned = Self;
23669
23670        #[inline(always)]
23671        fn inline_align(_context: fidl::encoding::Context) -> usize {
23672            8
23673        }
23674
23675        #[inline(always)]
23676        fn inline_size(_context: fidl::encoding::Context) -> usize {
23677            16
23678        }
23679    }
23680
23681    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DomainFormat, D>
23682        for &DomainFormat
23683    {
23684        #[inline]
23685        unsafe fn encode(
23686            self,
23687            encoder: &mut fidl::encoding::Encoder<'_, D>,
23688            offset: usize,
23689            _depth: fidl::encoding::Depth,
23690        ) -> fidl::Result<()> {
23691            encoder.debug_check_bounds::<DomainFormat>(offset);
23692            encoder.write_num::<u64>(self.ordinal(), offset);
23693            match self {
23694                DomainFormat::Audio(ref val) => {
23695                    fidl::encoding::encode_in_envelope::<AudioFormat, D>(
23696                        <AudioFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23697                        encoder,
23698                        offset + 8,
23699                        _depth,
23700                    )
23701                }
23702                DomainFormat::Video(ref val) => {
23703                    fidl::encoding::encode_in_envelope::<VideoFormat, D>(
23704                        <VideoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23705                        encoder,
23706                        offset + 8,
23707                        _depth,
23708                    )
23709                }
23710                DomainFormat::Crypto(ref val) => {
23711                    fidl::encoding::encode_in_envelope::<CryptoFormat, D>(
23712                        <CryptoFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
23713                        encoder,
23714                        offset + 8,
23715                        _depth,
23716                    )
23717                }
23718            }
23719        }
23720    }
23721
23722    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DomainFormat {
23723        #[inline(always)]
23724        fn new_empty() -> Self {
23725            Self::Audio(fidl::new_empty!(AudioFormat, D))
23726        }
23727
23728        #[inline]
23729        unsafe fn decode(
23730            &mut self,
23731            decoder: &mut fidl::encoding::Decoder<'_, D>,
23732            offset: usize,
23733            mut depth: fidl::encoding::Depth,
23734        ) -> fidl::Result<()> {
23735            decoder.debug_check_bounds::<Self>(offset);
23736            #[allow(unused_variables)]
23737            let next_out_of_line = decoder.next_out_of_line();
23738            let handles_before = decoder.remaining_handles();
23739            let (ordinal, inlined, num_bytes, num_handles) =
23740                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23741
23742            let member_inline_size = match ordinal {
23743                1 => <AudioFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23744                2 => <VideoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23745                3 => <CryptoFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context),
23746                _ => return Err(fidl::Error::UnknownUnionTag),
23747            };
23748
23749            if inlined != (member_inline_size <= 4) {
23750                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23751            }
23752            let _inner_offset;
23753            if inlined {
23754                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23755                _inner_offset = offset + 8;
23756            } else {
23757                depth.increment()?;
23758                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23759            }
23760            match ordinal {
23761                1 => {
23762                    #[allow(irrefutable_let_patterns)]
23763                    if let DomainFormat::Audio(_) = self {
23764                        // Do nothing, read the value into the object
23765                    } else {
23766                        // Initialize `self` to the right variant
23767                        *self = DomainFormat::Audio(fidl::new_empty!(AudioFormat, D));
23768                    }
23769                    #[allow(irrefutable_let_patterns)]
23770                    if let DomainFormat::Audio(ref mut val) = self {
23771                        fidl::decode!(AudioFormat, D, val, decoder, _inner_offset, depth)?;
23772                    } else {
23773                        unreachable!()
23774                    }
23775                }
23776                2 => {
23777                    #[allow(irrefutable_let_patterns)]
23778                    if let DomainFormat::Video(_) = self {
23779                        // Do nothing, read the value into the object
23780                    } else {
23781                        // Initialize `self` to the right variant
23782                        *self = DomainFormat::Video(fidl::new_empty!(VideoFormat, D));
23783                    }
23784                    #[allow(irrefutable_let_patterns)]
23785                    if let DomainFormat::Video(ref mut val) = self {
23786                        fidl::decode!(VideoFormat, D, val, decoder, _inner_offset, depth)?;
23787                    } else {
23788                        unreachable!()
23789                    }
23790                }
23791                3 => {
23792                    #[allow(irrefutable_let_patterns)]
23793                    if let DomainFormat::Crypto(_) = self {
23794                        // Do nothing, read the value into the object
23795                    } else {
23796                        // Initialize `self` to the right variant
23797                        *self = DomainFormat::Crypto(fidl::new_empty!(CryptoFormat, D));
23798                    }
23799                    #[allow(irrefutable_let_patterns)]
23800                    if let DomainFormat::Crypto(ref mut val) = self {
23801                        fidl::decode!(CryptoFormat, D, val, decoder, _inner_offset, depth)?;
23802                    } else {
23803                        unreachable!()
23804                    }
23805                }
23806                ordinal => panic!("unexpected ordinal {:?}", ordinal),
23807            }
23808            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
23809                return Err(fidl::Error::InvalidNumBytesInEnvelope);
23810            }
23811            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23812                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23813            }
23814            Ok(())
23815        }
23816    }
23817
23818    impl fidl::encoding::ValueTypeMarker for EncoderSettings {
23819        type Borrowed<'a> = &'a Self;
23820        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23821            value
23822        }
23823    }
23824
23825    unsafe impl fidl::encoding::TypeMarker for EncoderSettings {
23826        type Owned = Self;
23827
23828        #[inline(always)]
23829        fn inline_align(_context: fidl::encoding::Context) -> usize {
23830            8
23831        }
23832
23833        #[inline(always)]
23834        fn inline_size(_context: fidl::encoding::Context) -> usize {
23835            16
23836        }
23837    }
23838
23839    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EncoderSettings, D>
23840        for &EncoderSettings
23841    {
23842        #[inline]
23843        unsafe fn encode(
23844            self,
23845            encoder: &mut fidl::encoding::Encoder<'_, D>,
23846            offset: usize,
23847            _depth: fidl::encoding::Depth,
23848        ) -> fidl::Result<()> {
23849            encoder.debug_check_bounds::<EncoderSettings>(offset);
23850            encoder.write_num::<u64>(self.ordinal(), offset);
23851            match self {
23852                EncoderSettings::Sbc(ref val) => {
23853                    fidl::encoding::encode_in_envelope::<SbcEncoderSettings, D>(
23854                        <SbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23855                        encoder,
23856                        offset + 8,
23857                        _depth,
23858                    )
23859                }
23860                EncoderSettings::Aac(ref val) => {
23861                    fidl::encoding::encode_in_envelope::<AacEncoderSettings, D>(
23862                        <AacEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23863                        encoder,
23864                        offset + 8,
23865                        _depth,
23866                    )
23867                }
23868                EncoderSettings::H264(ref val) => {
23869                    fidl::encoding::encode_in_envelope::<H264EncoderSettings, D>(
23870                        <H264EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23871                        encoder,
23872                        offset + 8,
23873                        _depth,
23874                    )
23875                }
23876                EncoderSettings::Hevc(ref val) => {
23877                    fidl::encoding::encode_in_envelope::<HevcEncoderSettings, D>(
23878                        <HevcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23879                        encoder,
23880                        offset + 8,
23881                        _depth,
23882                    )
23883                }
23884                EncoderSettings::Cvsd(ref val) => {
23885                    fidl::encoding::encode_in_envelope::<CvsdEncoderSettings, D>(
23886                        <CvsdEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23887                        encoder,
23888                        offset + 8,
23889                        _depth,
23890                    )
23891                }
23892                EncoderSettings::Lc3(ref val) => {
23893                    fidl::encoding::encode_in_envelope::<Lc3EncoderSettings, D>(
23894                        <Lc3EncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23895                        encoder,
23896                        offset + 8,
23897                        _depth,
23898                    )
23899                }
23900                EncoderSettings::Msbc(ref val) => {
23901                    fidl::encoding::encode_in_envelope::<MSbcEncoderSettings, D>(
23902                        <MSbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
23903                        encoder,
23904                        offset + 8,
23905                        _depth,
23906                    )
23907                }
23908                EncoderSettings::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
23909            }
23910        }
23911    }
23912
23913    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EncoderSettings {
23914        #[inline(always)]
23915        fn new_empty() -> Self {
23916            Self::__SourceBreaking { unknown_ordinal: 0 }
23917        }
23918
23919        #[inline]
23920        unsafe fn decode(
23921            &mut self,
23922            decoder: &mut fidl::encoding::Decoder<'_, D>,
23923            offset: usize,
23924            mut depth: fidl::encoding::Depth,
23925        ) -> fidl::Result<()> {
23926            decoder.debug_check_bounds::<Self>(offset);
23927            #[allow(unused_variables)]
23928            let next_out_of_line = decoder.next_out_of_line();
23929            let handles_before = decoder.remaining_handles();
23930            let (ordinal, inlined, num_bytes, num_handles) =
23931                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
23932
23933            let member_inline_size = match ordinal {
23934                1 => {
23935                    <SbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23936                }
23937                2 => {
23938                    <AacEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23939                }
23940                3 => <H264EncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23941                    decoder.context,
23942                ),
23943                4 => <HevcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23944                    decoder.context,
23945                ),
23946                5 => <CvsdEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23947                    decoder.context,
23948                ),
23949                6 => {
23950                    <Lc3EncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context)
23951                }
23952                7 => <MSbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
23953                    decoder.context,
23954                ),
23955                0 => return Err(fidl::Error::UnknownUnionTag),
23956                _ => num_bytes as usize,
23957            };
23958
23959            if inlined != (member_inline_size <= 4) {
23960                return Err(fidl::Error::InvalidInlineBitInEnvelope);
23961            }
23962            let _inner_offset;
23963            if inlined {
23964                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
23965                _inner_offset = offset + 8;
23966            } else {
23967                depth.increment()?;
23968                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23969            }
23970            match ordinal {
23971                1 => {
23972                    #[allow(irrefutable_let_patterns)]
23973                    if let EncoderSettings::Sbc(_) = self {
23974                        // Do nothing, read the value into the object
23975                    } else {
23976                        // Initialize `self` to the right variant
23977                        *self = EncoderSettings::Sbc(fidl::new_empty!(SbcEncoderSettings, D));
23978                    }
23979                    #[allow(irrefutable_let_patterns)]
23980                    if let EncoderSettings::Sbc(ref mut val) = self {
23981                        fidl::decode!(SbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23982                    } else {
23983                        unreachable!()
23984                    }
23985                }
23986                2 => {
23987                    #[allow(irrefutable_let_patterns)]
23988                    if let EncoderSettings::Aac(_) = self {
23989                        // Do nothing, read the value into the object
23990                    } else {
23991                        // Initialize `self` to the right variant
23992                        *self = EncoderSettings::Aac(fidl::new_empty!(AacEncoderSettings, D));
23993                    }
23994                    #[allow(irrefutable_let_patterns)]
23995                    if let EncoderSettings::Aac(ref mut val) = self {
23996                        fidl::decode!(AacEncoderSettings, D, val, decoder, _inner_offset, depth)?;
23997                    } else {
23998                        unreachable!()
23999                    }
24000                }
24001                3 => {
24002                    #[allow(irrefutable_let_patterns)]
24003                    if let EncoderSettings::H264(_) = self {
24004                        // Do nothing, read the value into the object
24005                    } else {
24006                        // Initialize `self` to the right variant
24007                        *self = EncoderSettings::H264(fidl::new_empty!(H264EncoderSettings, D));
24008                    }
24009                    #[allow(irrefutable_let_patterns)]
24010                    if let EncoderSettings::H264(ref mut val) = self {
24011                        fidl::decode!(H264EncoderSettings, D, val, decoder, _inner_offset, depth)?;
24012                    } else {
24013                        unreachable!()
24014                    }
24015                }
24016                4 => {
24017                    #[allow(irrefutable_let_patterns)]
24018                    if let EncoderSettings::Hevc(_) = self {
24019                        // Do nothing, read the value into the object
24020                    } else {
24021                        // Initialize `self` to the right variant
24022                        *self = EncoderSettings::Hevc(fidl::new_empty!(HevcEncoderSettings, D));
24023                    }
24024                    #[allow(irrefutable_let_patterns)]
24025                    if let EncoderSettings::Hevc(ref mut val) = self {
24026                        fidl::decode!(HevcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24027                    } else {
24028                        unreachable!()
24029                    }
24030                }
24031                5 => {
24032                    #[allow(irrefutable_let_patterns)]
24033                    if let EncoderSettings::Cvsd(_) = self {
24034                        // Do nothing, read the value into the object
24035                    } else {
24036                        // Initialize `self` to the right variant
24037                        *self = EncoderSettings::Cvsd(fidl::new_empty!(CvsdEncoderSettings, D));
24038                    }
24039                    #[allow(irrefutable_let_patterns)]
24040                    if let EncoderSettings::Cvsd(ref mut val) = self {
24041                        fidl::decode!(CvsdEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24042                    } else {
24043                        unreachable!()
24044                    }
24045                }
24046                6 => {
24047                    #[allow(irrefutable_let_patterns)]
24048                    if let EncoderSettings::Lc3(_) = self {
24049                        // Do nothing, read the value into the object
24050                    } else {
24051                        // Initialize `self` to the right variant
24052                        *self = EncoderSettings::Lc3(fidl::new_empty!(Lc3EncoderSettings, D));
24053                    }
24054                    #[allow(irrefutable_let_patterns)]
24055                    if let EncoderSettings::Lc3(ref mut val) = self {
24056                        fidl::decode!(Lc3EncoderSettings, D, val, decoder, _inner_offset, depth)?;
24057                    } else {
24058                        unreachable!()
24059                    }
24060                }
24061                7 => {
24062                    #[allow(irrefutable_let_patterns)]
24063                    if let EncoderSettings::Msbc(_) = self {
24064                        // Do nothing, read the value into the object
24065                    } else {
24066                        // Initialize `self` to the right variant
24067                        *self = EncoderSettings::Msbc(fidl::new_empty!(MSbcEncoderSettings, D));
24068                    }
24069                    #[allow(irrefutable_let_patterns)]
24070                    if let EncoderSettings::Msbc(ref mut val) = self {
24071                        fidl::decode!(MSbcEncoderSettings, D, val, decoder, _inner_offset, depth)?;
24072                    } else {
24073                        unreachable!()
24074                    }
24075                }
24076                #[allow(deprecated)]
24077                ordinal => {
24078                    for _ in 0..num_handles {
24079                        decoder.drop_next_handle()?;
24080                    }
24081                    *self = EncoderSettings::__SourceBreaking { unknown_ordinal: ordinal };
24082                }
24083            }
24084            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24085                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24086            }
24087            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24088                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24089            }
24090            Ok(())
24091        }
24092    }
24093
24094    impl fidl::encoding::ValueTypeMarker for MediumSpecificStreamType {
24095        type Borrowed<'a> = &'a Self;
24096        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24097            value
24098        }
24099    }
24100
24101    unsafe impl fidl::encoding::TypeMarker for MediumSpecificStreamType {
24102        type Owned = Self;
24103
24104        #[inline(always)]
24105        fn inline_align(_context: fidl::encoding::Context) -> usize {
24106            8
24107        }
24108
24109        #[inline(always)]
24110        fn inline_size(_context: fidl::encoding::Context) -> usize {
24111            16
24112        }
24113    }
24114
24115    unsafe impl<D: fidl::encoding::ResourceDialect>
24116        fidl::encoding::Encode<MediumSpecificStreamType, D> for &MediumSpecificStreamType
24117    {
24118        #[inline]
24119        unsafe fn encode(
24120            self,
24121            encoder: &mut fidl::encoding::Encoder<'_, D>,
24122            offset: usize,
24123            _depth: fidl::encoding::Depth,
24124        ) -> fidl::Result<()> {
24125            encoder.debug_check_bounds::<MediumSpecificStreamType>(offset);
24126            encoder.write_num::<u64>(self.ordinal(), offset);
24127            match self {
24128                MediumSpecificStreamType::Audio(ref val) => {
24129                    fidl::encoding::encode_in_envelope::<AudioStreamType, D>(
24130                        <AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24131                        encoder,
24132                        offset + 8,
24133                        _depth,
24134                    )
24135                }
24136                MediumSpecificStreamType::Video(ref val) => {
24137                    fidl::encoding::encode_in_envelope::<VideoStreamType, D>(
24138                        <VideoStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24139                        encoder,
24140                        offset + 8,
24141                        _depth,
24142                    )
24143                }
24144                MediumSpecificStreamType::Text(ref val) => {
24145                    fidl::encoding::encode_in_envelope::<TextStreamType, D>(
24146                        <TextStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24147                        encoder,
24148                        offset + 8,
24149                        _depth,
24150                    )
24151                }
24152                MediumSpecificStreamType::Subpicture(ref val) => {
24153                    fidl::encoding::encode_in_envelope::<SubpictureStreamType, D>(
24154                        <SubpictureStreamType as fidl::encoding::ValueTypeMarker>::borrow(val),
24155                        encoder,
24156                        offset + 8,
24157                        _depth,
24158                    )
24159                }
24160            }
24161        }
24162    }
24163
24164    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
24165        for MediumSpecificStreamType
24166    {
24167        #[inline(always)]
24168        fn new_empty() -> Self {
24169            Self::Audio(fidl::new_empty!(AudioStreamType, D))
24170        }
24171
24172        #[inline]
24173        unsafe fn decode(
24174            &mut self,
24175            decoder: &mut fidl::encoding::Decoder<'_, D>,
24176            offset: usize,
24177            mut depth: fidl::encoding::Depth,
24178        ) -> fidl::Result<()> {
24179            decoder.debug_check_bounds::<Self>(offset);
24180            #[allow(unused_variables)]
24181            let next_out_of_line = decoder.next_out_of_line();
24182            let handles_before = decoder.remaining_handles();
24183            let (ordinal, inlined, num_bytes, num_handles) =
24184                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24185
24186            let member_inline_size = match ordinal {
24187                1 => <AudioStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24188                2 => <VideoStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24189                3 => <TextStreamType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24190                4 => <SubpictureStreamType as fidl::encoding::TypeMarker>::inline_size(
24191                    decoder.context,
24192                ),
24193                _ => return Err(fidl::Error::UnknownUnionTag),
24194            };
24195
24196            if inlined != (member_inline_size <= 4) {
24197                return Err(fidl::Error::InvalidInlineBitInEnvelope);
24198            }
24199            let _inner_offset;
24200            if inlined {
24201                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24202                _inner_offset = offset + 8;
24203            } else {
24204                depth.increment()?;
24205                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24206            }
24207            match ordinal {
24208                1 => {
24209                    #[allow(irrefutable_let_patterns)]
24210                    if let MediumSpecificStreamType::Audio(_) = self {
24211                        // Do nothing, read the value into the object
24212                    } else {
24213                        // Initialize `self` to the right variant
24214                        *self =
24215                            MediumSpecificStreamType::Audio(fidl::new_empty!(AudioStreamType, D));
24216                    }
24217                    #[allow(irrefutable_let_patterns)]
24218                    if let MediumSpecificStreamType::Audio(ref mut val) = self {
24219                        fidl::decode!(AudioStreamType, D, val, decoder, _inner_offset, depth)?;
24220                    } else {
24221                        unreachable!()
24222                    }
24223                }
24224                2 => {
24225                    #[allow(irrefutable_let_patterns)]
24226                    if let MediumSpecificStreamType::Video(_) = self {
24227                        // Do nothing, read the value into the object
24228                    } else {
24229                        // Initialize `self` to the right variant
24230                        *self =
24231                            MediumSpecificStreamType::Video(fidl::new_empty!(VideoStreamType, D));
24232                    }
24233                    #[allow(irrefutable_let_patterns)]
24234                    if let MediumSpecificStreamType::Video(ref mut val) = self {
24235                        fidl::decode!(VideoStreamType, D, val, decoder, _inner_offset, depth)?;
24236                    } else {
24237                        unreachable!()
24238                    }
24239                }
24240                3 => {
24241                    #[allow(irrefutable_let_patterns)]
24242                    if let MediumSpecificStreamType::Text(_) = self {
24243                        // Do nothing, read the value into the object
24244                    } else {
24245                        // Initialize `self` to the right variant
24246                        *self = MediumSpecificStreamType::Text(fidl::new_empty!(TextStreamType, D));
24247                    }
24248                    #[allow(irrefutable_let_patterns)]
24249                    if let MediumSpecificStreamType::Text(ref mut val) = self {
24250                        fidl::decode!(TextStreamType, D, val, decoder, _inner_offset, depth)?;
24251                    } else {
24252                        unreachable!()
24253                    }
24254                }
24255                4 => {
24256                    #[allow(irrefutable_let_patterns)]
24257                    if let MediumSpecificStreamType::Subpicture(_) = self {
24258                        // Do nothing, read the value into the object
24259                    } else {
24260                        // Initialize `self` to the right variant
24261                        *self = MediumSpecificStreamType::Subpicture(fidl::new_empty!(
24262                            SubpictureStreamType,
24263                            D
24264                        ));
24265                    }
24266                    #[allow(irrefutable_let_patterns)]
24267                    if let MediumSpecificStreamType::Subpicture(ref mut val) = self {
24268                        fidl::decode!(SubpictureStreamType, D, val, decoder, _inner_offset, depth)?;
24269                    } else {
24270                        unreachable!()
24271                    }
24272                }
24273                ordinal => panic!("unexpected ordinal {:?}", ordinal),
24274            }
24275            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24276                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24277            }
24278            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24279                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24280            }
24281            Ok(())
24282        }
24283    }
24284
24285    impl fidl::encoding::ValueTypeMarker for Usage {
24286        type Borrowed<'a> = &'a Self;
24287        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24288            value
24289        }
24290    }
24291
24292    unsafe impl fidl::encoding::TypeMarker for Usage {
24293        type Owned = Self;
24294
24295        #[inline(always)]
24296        fn inline_align(_context: fidl::encoding::Context) -> usize {
24297            8
24298        }
24299
24300        #[inline(always)]
24301        fn inline_size(_context: fidl::encoding::Context) -> usize {
24302            16
24303        }
24304    }
24305
24306    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage, D> for &Usage {
24307        #[inline]
24308        unsafe fn encode(
24309            self,
24310            encoder: &mut fidl::encoding::Encoder<'_, D>,
24311            offset: usize,
24312            _depth: fidl::encoding::Depth,
24313        ) -> fidl::Result<()> {
24314            encoder.debug_check_bounds::<Usage>(offset);
24315            encoder.write_num::<u64>(self.ordinal(), offset);
24316            match self {
24317                Usage::RenderUsage(ref val) => {
24318                    fidl::encoding::encode_in_envelope::<AudioRenderUsage, D>(
24319                        <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24320                        encoder,
24321                        offset + 8,
24322                        _depth,
24323                    )
24324                }
24325                Usage::CaptureUsage(ref val) => {
24326                    fidl::encoding::encode_in_envelope::<AudioCaptureUsage, D>(
24327                        <AudioCaptureUsage as fidl::encoding::ValueTypeMarker>::borrow(val),
24328                        encoder,
24329                        offset + 8,
24330                        _depth,
24331                    )
24332                }
24333            }
24334        }
24335    }
24336
24337    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage {
24338        #[inline(always)]
24339        fn new_empty() -> Self {
24340            Self::RenderUsage(fidl::new_empty!(AudioRenderUsage, D))
24341        }
24342
24343        #[inline]
24344        unsafe fn decode(
24345            &mut self,
24346            decoder: &mut fidl::encoding::Decoder<'_, D>,
24347            offset: usize,
24348            mut depth: fidl::encoding::Depth,
24349        ) -> fidl::Result<()> {
24350            decoder.debug_check_bounds::<Self>(offset);
24351            #[allow(unused_variables)]
24352            let next_out_of_line = decoder.next_out_of_line();
24353            let handles_before = decoder.remaining_handles();
24354            let (ordinal, inlined, num_bytes, num_handles) =
24355                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24356
24357            let member_inline_size = match ordinal {
24358                1 => <AudioRenderUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24359                2 => {
24360                    <AudioCaptureUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24361                }
24362                _ => return Err(fidl::Error::UnknownUnionTag),
24363            };
24364
24365            if inlined != (member_inline_size <= 4) {
24366                return Err(fidl::Error::InvalidInlineBitInEnvelope);
24367            }
24368            let _inner_offset;
24369            if inlined {
24370                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24371                _inner_offset = offset + 8;
24372            } else {
24373                depth.increment()?;
24374                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24375            }
24376            match ordinal {
24377                1 => {
24378                    #[allow(irrefutable_let_patterns)]
24379                    if let Usage::RenderUsage(_) = self {
24380                        // Do nothing, read the value into the object
24381                    } else {
24382                        // Initialize `self` to the right variant
24383                        *self = Usage::RenderUsage(fidl::new_empty!(AudioRenderUsage, D));
24384                    }
24385                    #[allow(irrefutable_let_patterns)]
24386                    if let Usage::RenderUsage(ref mut val) = self {
24387                        fidl::decode!(AudioRenderUsage, D, val, decoder, _inner_offset, depth)?;
24388                    } else {
24389                        unreachable!()
24390                    }
24391                }
24392                2 => {
24393                    #[allow(irrefutable_let_patterns)]
24394                    if let Usage::CaptureUsage(_) = self {
24395                        // Do nothing, read the value into the object
24396                    } else {
24397                        // Initialize `self` to the right variant
24398                        *self = Usage::CaptureUsage(fidl::new_empty!(AudioCaptureUsage, D));
24399                    }
24400                    #[allow(irrefutable_let_patterns)]
24401                    if let Usage::CaptureUsage(ref mut val) = self {
24402                        fidl::decode!(AudioCaptureUsage, D, val, decoder, _inner_offset, depth)?;
24403                    } else {
24404                        unreachable!()
24405                    }
24406                }
24407                ordinal => panic!("unexpected ordinal {:?}", ordinal),
24408            }
24409            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24410                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24411            }
24412            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24413                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24414            }
24415            Ok(())
24416        }
24417    }
24418
24419    impl fidl::encoding::ValueTypeMarker for Usage2 {
24420        type Borrowed<'a> = &'a Self;
24421        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24422            value
24423        }
24424    }
24425
24426    unsafe impl fidl::encoding::TypeMarker for Usage2 {
24427        type Owned = Self;
24428
24429        #[inline(always)]
24430        fn inline_align(_context: fidl::encoding::Context) -> usize {
24431            8
24432        }
24433
24434        #[inline(always)]
24435        fn inline_size(_context: fidl::encoding::Context) -> usize {
24436            16
24437        }
24438    }
24439
24440    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Usage2, D> for &Usage2 {
24441        #[inline]
24442        unsafe fn encode(
24443            self,
24444            encoder: &mut fidl::encoding::Encoder<'_, D>,
24445            offset: usize,
24446            _depth: fidl::encoding::Depth,
24447        ) -> fidl::Result<()> {
24448            encoder.debug_check_bounds::<Usage2>(offset);
24449            encoder.write_num::<u64>(self.ordinal(), offset);
24450            match self {
24451                Usage2::RenderUsage(ref val) => {
24452                    fidl::encoding::encode_in_envelope::<AudioRenderUsage2, D>(
24453                        <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24454                        encoder,
24455                        offset + 8,
24456                        _depth,
24457                    )
24458                }
24459                Usage2::CaptureUsage(ref val) => {
24460                    fidl::encoding::encode_in_envelope::<AudioCaptureUsage2, D>(
24461                        <AudioCaptureUsage2 as fidl::encoding::ValueTypeMarker>::borrow(val),
24462                        encoder,
24463                        offset + 8,
24464                        _depth,
24465                    )
24466                }
24467                Usage2::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24468            }
24469        }
24470    }
24471
24472    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Usage2 {
24473        #[inline(always)]
24474        fn new_empty() -> Self {
24475            Self::__SourceBreaking { unknown_ordinal: 0 }
24476        }
24477
24478        #[inline]
24479        unsafe fn decode(
24480            &mut self,
24481            decoder: &mut fidl::encoding::Decoder<'_, D>,
24482            offset: usize,
24483            mut depth: fidl::encoding::Depth,
24484        ) -> fidl::Result<()> {
24485            decoder.debug_check_bounds::<Self>(offset);
24486            #[allow(unused_variables)]
24487            let next_out_of_line = decoder.next_out_of_line();
24488            let handles_before = decoder.remaining_handles();
24489            let (ordinal, inlined, num_bytes, num_handles) =
24490                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24491
24492            let member_inline_size = match ordinal {
24493                1 => {
24494                    <AudioRenderUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24495                }
24496                2 => {
24497                    <AudioCaptureUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context)
24498                }
24499                0 => return Err(fidl::Error::UnknownUnionTag),
24500                _ => num_bytes as usize,
24501            };
24502
24503            if inlined != (member_inline_size <= 4) {
24504                return Err(fidl::Error::InvalidInlineBitInEnvelope);
24505            }
24506            let _inner_offset;
24507            if inlined {
24508                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24509                _inner_offset = offset + 8;
24510            } else {
24511                depth.increment()?;
24512                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24513            }
24514            match ordinal {
24515                1 => {
24516                    #[allow(irrefutable_let_patterns)]
24517                    if let Usage2::RenderUsage(_) = self {
24518                        // Do nothing, read the value into the object
24519                    } else {
24520                        // Initialize `self` to the right variant
24521                        *self = Usage2::RenderUsage(fidl::new_empty!(AudioRenderUsage2, D));
24522                    }
24523                    #[allow(irrefutable_let_patterns)]
24524                    if let Usage2::RenderUsage(ref mut val) = self {
24525                        fidl::decode!(AudioRenderUsage2, D, val, decoder, _inner_offset, depth)?;
24526                    } else {
24527                        unreachable!()
24528                    }
24529                }
24530                2 => {
24531                    #[allow(irrefutable_let_patterns)]
24532                    if let Usage2::CaptureUsage(_) = self {
24533                        // Do nothing, read the value into the object
24534                    } else {
24535                        // Initialize `self` to the right variant
24536                        *self = Usage2::CaptureUsage(fidl::new_empty!(AudioCaptureUsage2, D));
24537                    }
24538                    #[allow(irrefutable_let_patterns)]
24539                    if let Usage2::CaptureUsage(ref mut val) = self {
24540                        fidl::decode!(AudioCaptureUsage2, D, val, decoder, _inner_offset, depth)?;
24541                    } else {
24542                        unreachable!()
24543                    }
24544                }
24545                #[allow(deprecated)]
24546                ordinal => {
24547                    for _ in 0..num_handles {
24548                        decoder.drop_next_handle()?;
24549                    }
24550                    *self = Usage2::__SourceBreaking { unknown_ordinal: ordinal };
24551                }
24552            }
24553            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24554                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24555            }
24556            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24557                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24558            }
24559            Ok(())
24560        }
24561    }
24562
24563    impl fidl::encoding::ValueTypeMarker for UsageState {
24564        type Borrowed<'a> = &'a Self;
24565        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24566            value
24567        }
24568    }
24569
24570    unsafe impl fidl::encoding::TypeMarker for UsageState {
24571        type Owned = Self;
24572
24573        #[inline(always)]
24574        fn inline_align(_context: fidl::encoding::Context) -> usize {
24575            8
24576        }
24577
24578        #[inline(always)]
24579        fn inline_size(_context: fidl::encoding::Context) -> usize {
24580            16
24581        }
24582    }
24583
24584    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UsageState, D>
24585        for &UsageState
24586    {
24587        #[inline]
24588        unsafe fn encode(
24589            self,
24590            encoder: &mut fidl::encoding::Encoder<'_, D>,
24591            offset: usize,
24592            _depth: fidl::encoding::Depth,
24593        ) -> fidl::Result<()> {
24594            encoder.debug_check_bounds::<UsageState>(offset);
24595            encoder.write_num::<u64>(self.ordinal(), offset);
24596            match self {
24597                UsageState::Unadjusted(ref val) => {
24598                    fidl::encoding::encode_in_envelope::<UsageStateUnadjusted, D>(
24599                        <UsageStateUnadjusted as fidl::encoding::ValueTypeMarker>::borrow(val),
24600                        encoder,
24601                        offset + 8,
24602                        _depth,
24603                    )
24604                }
24605                UsageState::Ducked(ref val) => {
24606                    fidl::encoding::encode_in_envelope::<UsageStateDucked, D>(
24607                        <UsageStateDucked as fidl::encoding::ValueTypeMarker>::borrow(val),
24608                        encoder,
24609                        offset + 8,
24610                        _depth,
24611                    )
24612                }
24613                UsageState::Muted(ref val) => {
24614                    fidl::encoding::encode_in_envelope::<UsageStateMuted, D>(
24615                        <UsageStateMuted as fidl::encoding::ValueTypeMarker>::borrow(val),
24616                        encoder,
24617                        offset + 8,
24618                        _depth,
24619                    )
24620                }
24621                UsageState::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
24622            }
24623        }
24624    }
24625
24626    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UsageState {
24627        #[inline(always)]
24628        fn new_empty() -> Self {
24629            Self::__SourceBreaking { unknown_ordinal: 0 }
24630        }
24631
24632        #[inline]
24633        unsafe fn decode(
24634            &mut self,
24635            decoder: &mut fidl::encoding::Decoder<'_, D>,
24636            offset: usize,
24637            mut depth: fidl::encoding::Depth,
24638        ) -> fidl::Result<()> {
24639            decoder.debug_check_bounds::<Self>(offset);
24640            #[allow(unused_variables)]
24641            let next_out_of_line = decoder.next_out_of_line();
24642            let handles_before = decoder.remaining_handles();
24643            let (ordinal, inlined, num_bytes, num_handles) =
24644                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24645
24646            let member_inline_size = match ordinal {
24647                1 => <UsageStateUnadjusted as fidl::encoding::TypeMarker>::inline_size(
24648                    decoder.context,
24649                ),
24650                2 => <UsageStateDucked as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24651                3 => <UsageStateMuted as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24652                0 => return Err(fidl::Error::UnknownUnionTag),
24653                _ => num_bytes as usize,
24654            };
24655
24656            if inlined != (member_inline_size <= 4) {
24657                return Err(fidl::Error::InvalidInlineBitInEnvelope);
24658            }
24659            let _inner_offset;
24660            if inlined {
24661                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24662                _inner_offset = offset + 8;
24663            } else {
24664                depth.increment()?;
24665                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24666            }
24667            match ordinal {
24668                1 => {
24669                    #[allow(irrefutable_let_patterns)]
24670                    if let UsageState::Unadjusted(_) = self {
24671                        // Do nothing, read the value into the object
24672                    } else {
24673                        // Initialize `self` to the right variant
24674                        *self = UsageState::Unadjusted(fidl::new_empty!(UsageStateUnadjusted, D));
24675                    }
24676                    #[allow(irrefutable_let_patterns)]
24677                    if let UsageState::Unadjusted(ref mut val) = self {
24678                        fidl::decode!(UsageStateUnadjusted, D, val, decoder, _inner_offset, depth)?;
24679                    } else {
24680                        unreachable!()
24681                    }
24682                }
24683                2 => {
24684                    #[allow(irrefutable_let_patterns)]
24685                    if let UsageState::Ducked(_) = self {
24686                        // Do nothing, read the value into the object
24687                    } else {
24688                        // Initialize `self` to the right variant
24689                        *self = UsageState::Ducked(fidl::new_empty!(UsageStateDucked, D));
24690                    }
24691                    #[allow(irrefutable_let_patterns)]
24692                    if let UsageState::Ducked(ref mut val) = self {
24693                        fidl::decode!(UsageStateDucked, D, val, decoder, _inner_offset, depth)?;
24694                    } else {
24695                        unreachable!()
24696                    }
24697                }
24698                3 => {
24699                    #[allow(irrefutable_let_patterns)]
24700                    if let UsageState::Muted(_) = self {
24701                        // Do nothing, read the value into the object
24702                    } else {
24703                        // Initialize `self` to the right variant
24704                        *self = UsageState::Muted(fidl::new_empty!(UsageStateMuted, D));
24705                    }
24706                    #[allow(irrefutable_let_patterns)]
24707                    if let UsageState::Muted(ref mut val) = self {
24708                        fidl::decode!(UsageStateMuted, D, val, decoder, _inner_offset, depth)?;
24709                    } else {
24710                        unreachable!()
24711                    }
24712                }
24713                #[allow(deprecated)]
24714                ordinal => {
24715                    for _ in 0..num_handles {
24716                        decoder.drop_next_handle()?;
24717                    }
24718                    *self = UsageState::__SourceBreaking { unknown_ordinal: ordinal };
24719                }
24720            }
24721            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24722                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24723            }
24724            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24725                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24726            }
24727            Ok(())
24728        }
24729    }
24730
24731    impl fidl::encoding::ValueTypeMarker for Value {
24732        type Borrowed<'a> = &'a Self;
24733        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24734            value
24735        }
24736    }
24737
24738    unsafe impl fidl::encoding::TypeMarker for Value {
24739        type Owned = Self;
24740
24741        #[inline(always)]
24742        fn inline_align(_context: fidl::encoding::Context) -> usize {
24743            8
24744        }
24745
24746        #[inline(always)]
24747        fn inline_size(_context: fidl::encoding::Context) -> usize {
24748            16
24749        }
24750    }
24751
24752    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Value, D> for &Value {
24753        #[inline]
24754        unsafe fn encode(
24755            self,
24756            encoder: &mut fidl::encoding::Encoder<'_, D>,
24757            offset: usize,
24758            _depth: fidl::encoding::Depth,
24759        ) -> fidl::Result<()> {
24760            encoder.debug_check_bounds::<Value>(offset);
24761            encoder.write_num::<u64>(self.ordinal(), offset);
24762            match self {
24763            Value::BoolValue(ref val) => {
24764                fidl::encoding::encode_in_envelope::<bool, D>(
24765                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
24766                    encoder, offset + 8, _depth
24767                )
24768            }
24769            Value::Uint64Value(ref val) => {
24770                fidl::encoding::encode_in_envelope::<u64, D>(
24771                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24772                    encoder, offset + 8, _depth
24773                )
24774            }
24775            Value::Int64Value(ref val) => {
24776                fidl::encoding::encode_in_envelope::<i64, D>(
24777                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
24778                    encoder, offset + 8, _depth
24779                )
24780            }
24781            Value::StringValue(ref val) => {
24782                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, D>(
24783                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
24784                    encoder, offset + 8, _depth
24785                )
24786            }
24787            Value::BytesValue(ref val) => {
24788                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
24789                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
24790                    encoder, offset + 8, _depth
24791                )
24792            }
24793        }
24794        }
24795    }
24796
24797    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Value {
24798        #[inline(always)]
24799        fn new_empty() -> Self {
24800            Self::BoolValue(fidl::new_empty!(bool, D))
24801        }
24802
24803        #[inline]
24804        unsafe fn decode(
24805            &mut self,
24806            decoder: &mut fidl::encoding::Decoder<'_, D>,
24807            offset: usize,
24808            mut depth: fidl::encoding::Depth,
24809        ) -> fidl::Result<()> {
24810            decoder.debug_check_bounds::<Self>(offset);
24811            #[allow(unused_variables)]
24812            let next_out_of_line = decoder.next_out_of_line();
24813            let handles_before = decoder.remaining_handles();
24814            let (ordinal, inlined, num_bytes, num_handles) =
24815                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
24816
24817            let member_inline_size = match ordinal {
24818                1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24819                2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24820                3 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
24821                4 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
24822                    decoder.context,
24823                ),
24824                5 => {
24825                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
24826                        decoder.context,
24827                    )
24828                }
24829                _ => return Err(fidl::Error::UnknownUnionTag),
24830            };
24831
24832            if inlined != (member_inline_size <= 4) {
24833                return Err(fidl::Error::InvalidInlineBitInEnvelope);
24834            }
24835            let _inner_offset;
24836            if inlined {
24837                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
24838                _inner_offset = offset + 8;
24839            } else {
24840                depth.increment()?;
24841                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24842            }
24843            match ordinal {
24844                1 => {
24845                    #[allow(irrefutable_let_patterns)]
24846                    if let Value::BoolValue(_) = self {
24847                        // Do nothing, read the value into the object
24848                    } else {
24849                        // Initialize `self` to the right variant
24850                        *self = Value::BoolValue(fidl::new_empty!(bool, D));
24851                    }
24852                    #[allow(irrefutable_let_patterns)]
24853                    if let Value::BoolValue(ref mut val) = self {
24854                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
24855                    } else {
24856                        unreachable!()
24857                    }
24858                }
24859                2 => {
24860                    #[allow(irrefutable_let_patterns)]
24861                    if let Value::Uint64Value(_) = self {
24862                        // Do nothing, read the value into the object
24863                    } else {
24864                        // Initialize `self` to the right variant
24865                        *self = Value::Uint64Value(fidl::new_empty!(u64, D));
24866                    }
24867                    #[allow(irrefutable_let_patterns)]
24868                    if let Value::Uint64Value(ref mut val) = self {
24869                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
24870                    } else {
24871                        unreachable!()
24872                    }
24873                }
24874                3 => {
24875                    #[allow(irrefutable_let_patterns)]
24876                    if let Value::Int64Value(_) = self {
24877                        // Do nothing, read the value into the object
24878                    } else {
24879                        // Initialize `self` to the right variant
24880                        *self = Value::Int64Value(fidl::new_empty!(i64, D));
24881                    }
24882                    #[allow(irrefutable_let_patterns)]
24883                    if let Value::Int64Value(ref mut val) = self {
24884                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
24885                    } else {
24886                        unreachable!()
24887                    }
24888                }
24889                4 => {
24890                    #[allow(irrefutable_let_patterns)]
24891                    if let Value::StringValue(_) = self {
24892                        // Do nothing, read the value into the object
24893                    } else {
24894                        // Initialize `self` to the right variant
24895                        *self = Value::StringValue(fidl::new_empty!(
24896                            fidl::encoding::UnboundedString,
24897                            D
24898                        ));
24899                    }
24900                    #[allow(irrefutable_let_patterns)]
24901                    if let Value::StringValue(ref mut val) = self {
24902                        fidl::decode!(
24903                            fidl::encoding::UnboundedString,
24904                            D,
24905                            val,
24906                            decoder,
24907                            _inner_offset,
24908                            depth
24909                        )?;
24910                    } else {
24911                        unreachable!()
24912                    }
24913                }
24914                5 => {
24915                    #[allow(irrefutable_let_patterns)]
24916                    if let Value::BytesValue(_) = self {
24917                        // Do nothing, read the value into the object
24918                    } else {
24919                        // Initialize `self` to the right variant
24920                        *self = Value::BytesValue(fidl::new_empty!(
24921                            fidl::encoding::UnboundedVector<u8>,
24922                            D
24923                        ));
24924                    }
24925                    #[allow(irrefutable_let_patterns)]
24926                    if let Value::BytesValue(ref mut val) = self {
24927                        fidl::decode!(
24928                            fidl::encoding::UnboundedVector<u8>,
24929                            D,
24930                            val,
24931                            decoder,
24932                            _inner_offset,
24933                            depth
24934                        )?;
24935                    } else {
24936                        unreachable!()
24937                    }
24938                }
24939                ordinal => panic!("unexpected ordinal {:?}", ordinal),
24940            }
24941            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
24942                return Err(fidl::Error::InvalidNumBytesInEnvelope);
24943            }
24944            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24945                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24946            }
24947            Ok(())
24948        }
24949    }
24950
24951    impl fidl::encoding::ValueTypeMarker for VideoCompressedFormat {
24952        type Borrowed<'a> = &'a Self;
24953        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24954            value
24955        }
24956    }
24957
24958    unsafe impl fidl::encoding::TypeMarker for VideoCompressedFormat {
24959        type Owned = Self;
24960
24961        #[inline(always)]
24962        fn inline_align(_context: fidl::encoding::Context) -> usize {
24963            8
24964        }
24965
24966        #[inline(always)]
24967        fn inline_size(_context: fidl::encoding::Context) -> usize {
24968            16
24969        }
24970    }
24971
24972    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoCompressedFormat, D>
24973        for &VideoCompressedFormat
24974    {
24975        #[inline]
24976        unsafe fn encode(
24977            self,
24978            encoder: &mut fidl::encoding::Encoder<'_, D>,
24979            offset: usize,
24980            _depth: fidl::encoding::Depth,
24981        ) -> fidl::Result<()> {
24982            encoder.debug_check_bounds::<VideoCompressedFormat>(offset);
24983            encoder.write_num::<u64>(self.ordinal(), offset);
24984            match self {
24985                VideoCompressedFormat::TempFieldTodoRemove(ref val) => {
24986                    fidl::encoding::encode_in_envelope::<u32, D>(
24987                        <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
24988                        encoder,
24989                        offset + 8,
24990                        _depth,
24991                    )
24992                }
24993            }
24994        }
24995    }
24996
24997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoCompressedFormat {
24998        #[inline(always)]
24999        fn new_empty() -> Self {
25000            Self::TempFieldTodoRemove(fidl::new_empty!(u32, D))
25001        }
25002
25003        #[inline]
25004        unsafe fn decode(
25005            &mut self,
25006            decoder: &mut fidl::encoding::Decoder<'_, D>,
25007            offset: usize,
25008            mut depth: fidl::encoding::Depth,
25009        ) -> fidl::Result<()> {
25010            decoder.debug_check_bounds::<Self>(offset);
25011            #[allow(unused_variables)]
25012            let next_out_of_line = decoder.next_out_of_line();
25013            let handles_before = decoder.remaining_handles();
25014            let (ordinal, inlined, num_bytes, num_handles) =
25015                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25016
25017            let member_inline_size = match ordinal {
25018                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25019                _ => return Err(fidl::Error::UnknownUnionTag),
25020            };
25021
25022            if inlined != (member_inline_size <= 4) {
25023                return Err(fidl::Error::InvalidInlineBitInEnvelope);
25024            }
25025            let _inner_offset;
25026            if inlined {
25027                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25028                _inner_offset = offset + 8;
25029            } else {
25030                depth.increment()?;
25031                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25032            }
25033            match ordinal {
25034                1 => {
25035                    #[allow(irrefutable_let_patterns)]
25036                    if let VideoCompressedFormat::TempFieldTodoRemove(_) = self {
25037                        // Do nothing, read the value into the object
25038                    } else {
25039                        // Initialize `self` to the right variant
25040                        *self =
25041                            VideoCompressedFormat::TempFieldTodoRemove(fidl::new_empty!(u32, D));
25042                    }
25043                    #[allow(irrefutable_let_patterns)]
25044                    if let VideoCompressedFormat::TempFieldTodoRemove(ref mut val) = self {
25045                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
25046                    } else {
25047                        unreachable!()
25048                    }
25049                }
25050                ordinal => panic!("unexpected ordinal {:?}", ordinal),
25051            }
25052            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25053                return Err(fidl::Error::InvalidNumBytesInEnvelope);
25054            }
25055            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25056                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25057            }
25058            Ok(())
25059        }
25060    }
25061
25062    impl fidl::encoding::ValueTypeMarker for VideoFormat {
25063        type Borrowed<'a> = &'a Self;
25064        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25065            value
25066        }
25067    }
25068
25069    unsafe impl fidl::encoding::TypeMarker for VideoFormat {
25070        type Owned = Self;
25071
25072        #[inline(always)]
25073        fn inline_align(_context: fidl::encoding::Context) -> usize {
25074            8
25075        }
25076
25077        #[inline(always)]
25078        fn inline_size(_context: fidl::encoding::Context) -> usize {
25079            16
25080        }
25081    }
25082
25083    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VideoFormat, D>
25084        for &VideoFormat
25085    {
25086        #[inline]
25087        unsafe fn encode(
25088            self,
25089            encoder: &mut fidl::encoding::Encoder<'_, D>,
25090            offset: usize,
25091            _depth: fidl::encoding::Depth,
25092        ) -> fidl::Result<()> {
25093            encoder.debug_check_bounds::<VideoFormat>(offset);
25094            encoder.write_num::<u64>(self.ordinal(), offset);
25095            match self {
25096                VideoFormat::Compressed(ref val) => {
25097                    fidl::encoding::encode_in_envelope::<VideoCompressedFormat, D>(
25098                        <VideoCompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
25099                        encoder,
25100                        offset + 8,
25101                        _depth,
25102                    )
25103                }
25104                VideoFormat::Uncompressed(ref val) => {
25105                    fidl::encoding::encode_in_envelope::<VideoUncompressedFormat, D>(
25106                        <VideoUncompressedFormat as fidl::encoding::ValueTypeMarker>::borrow(val),
25107                        encoder,
25108                        offset + 8,
25109                        _depth,
25110                    )
25111                }
25112            }
25113        }
25114    }
25115
25116    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VideoFormat {
25117        #[inline(always)]
25118        fn new_empty() -> Self {
25119            Self::Compressed(fidl::new_empty!(VideoCompressedFormat, D))
25120        }
25121
25122        #[inline]
25123        unsafe fn decode(
25124            &mut self,
25125            decoder: &mut fidl::encoding::Decoder<'_, D>,
25126            offset: usize,
25127            mut depth: fidl::encoding::Depth,
25128        ) -> fidl::Result<()> {
25129            decoder.debug_check_bounds::<Self>(offset);
25130            #[allow(unused_variables)]
25131            let next_out_of_line = decoder.next_out_of_line();
25132            let handles_before = decoder.remaining_handles();
25133            let (ordinal, inlined, num_bytes, num_handles) =
25134                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25135
25136            let member_inline_size = match ordinal {
25137                1 => <VideoCompressedFormat as fidl::encoding::TypeMarker>::inline_size(
25138                    decoder.context,
25139                ),
25140                2 => <VideoUncompressedFormat as fidl::encoding::TypeMarker>::inline_size(
25141                    decoder.context,
25142                ),
25143                _ => return Err(fidl::Error::UnknownUnionTag),
25144            };
25145
25146            if inlined != (member_inline_size <= 4) {
25147                return Err(fidl::Error::InvalidInlineBitInEnvelope);
25148            }
25149            let _inner_offset;
25150            if inlined {
25151                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25152                _inner_offset = offset + 8;
25153            } else {
25154                depth.increment()?;
25155                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25156            }
25157            match ordinal {
25158                1 => {
25159                    #[allow(irrefutable_let_patterns)]
25160                    if let VideoFormat::Compressed(_) = self {
25161                        // Do nothing, read the value into the object
25162                    } else {
25163                        // Initialize `self` to the right variant
25164                        *self = VideoFormat::Compressed(fidl::new_empty!(VideoCompressedFormat, D));
25165                    }
25166                    #[allow(irrefutable_let_patterns)]
25167                    if let VideoFormat::Compressed(ref mut val) = self {
25168                        fidl::decode!(
25169                            VideoCompressedFormat,
25170                            D,
25171                            val,
25172                            decoder,
25173                            _inner_offset,
25174                            depth
25175                        )?;
25176                    } else {
25177                        unreachable!()
25178                    }
25179                }
25180                2 => {
25181                    #[allow(irrefutable_let_patterns)]
25182                    if let VideoFormat::Uncompressed(_) = self {
25183                        // Do nothing, read the value into the object
25184                    } else {
25185                        // Initialize `self` to the right variant
25186                        *self =
25187                            VideoFormat::Uncompressed(fidl::new_empty!(VideoUncompressedFormat, D));
25188                    }
25189                    #[allow(irrefutable_let_patterns)]
25190                    if let VideoFormat::Uncompressed(ref mut val) = self {
25191                        fidl::decode!(
25192                            VideoUncompressedFormat,
25193                            D,
25194                            val,
25195                            decoder,
25196                            _inner_offset,
25197                            depth
25198                        )?;
25199                    } else {
25200                        unreachable!()
25201                    }
25202                }
25203                ordinal => panic!("unexpected ordinal {:?}", ordinal),
25204            }
25205            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25206                return Err(fidl::Error::InvalidNumBytesInEnvelope);
25207            }
25208            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25209                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25210            }
25211            Ok(())
25212        }
25213    }
25214}