fidl_fuchsia_accessibility__common/
fidl_fuchsia_accessibility__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/// Specifies color correction mode.
12#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13#[repr(u32)]
14pub enum ColorCorrectionMode {
15    /// No color correction.
16    Disabled = 0,
17    /// Color correction for protanomaly (red-green -- reduced sensitivity to red light).
18    CorrectProtanomaly = 1,
19    /// Color correction for deuteranomaly (red-green -- reduced sensitivity to green light).
20    CorrectDeuteranomaly = 2,
21    /// Color correction for tritanomaly (blue-yellow -- reduced sensitivity to blue light).
22    CorrectTritanomaly = 3,
23}
24
25impl ColorCorrectionMode {
26    #[inline]
27    pub fn from_primitive(prim: u32) -> Option<Self> {
28        match prim {
29            0 => Some(Self::Disabled),
30            1 => Some(Self::CorrectProtanomaly),
31            2 => Some(Self::CorrectDeuteranomaly),
32            3 => Some(Self::CorrectTritanomaly),
33            _ => None,
34        }
35    }
36
37    #[inline]
38    pub const fn into_primitive(self) -> u32 {
39        self as u32
40    }
41}
42
43#[derive(Clone, Debug, PartialEq)]
44pub struct ColorTransformHandlerSetColorTransformConfigurationRequest {
45    pub configuration: ColorTransformConfiguration,
46}
47
48impl fidl::Persistable for ColorTransformHandlerSetColorTransformConfigurationRequest {}
49
50#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
51pub struct MagnificationHandlerSetClipSpaceTransformRequest {
52    pub x: f32,
53    pub y: f32,
54    pub scale: f32,
55}
56
57impl fidl::Persistable for MagnificationHandlerSetClipSpaceTransformRequest {}
58
59/// The current configuration for accessibility color transforms, which includes color inversion and
60/// color correction. This always includes the matrix required to apply the appropriate transforms.
61/// Color correction and color inversion may be active simultaneously.
62///
63/// For original RGB value (r, g, b) (each component ranged between 0 and 1), the RGB value of
64/// corrected color (r', g', b') is
65///   (r', g', b') = color_adjustment_post_offset
66///                + color_adjustment_matrix . ((r, g, b) + color_adjustment_pre_offset).
67#[derive(Clone, Debug, Default, PartialEq)]
68pub struct ColorTransformConfiguration {
69    /// When color_inversion_enabled is true, certain colors are inverted across the entire screen.
70    /// If this field is omitted behavior should remain unchanged.
71    pub color_inversion_enabled: Option<bool>,
72    /// When color_correction is set to DISABLED, colors are displayed normally. When
73    /// color_correction has different value, colors are modified to correct for the specified type
74    /// of color blindness. If this field is omitted behavior should remain unchanged.
75    pub color_correction: Option<ColorCorrectionMode>,
76    /// 3x3 Matrix in row-major form which will be used by root presenter to apply color correction
77    /// and color inversion, or a combination fo the two. This field should always be set.
78    pub color_adjustment_matrix: Option<[f32; 9]>,
79    /// 3x1 vector which is used by root presenter as an offset added to the original RGB color,
80    /// before it multiplies with the |color_adjustment_matrix|. This field should always be set.
81    pub color_adjustment_pre_offset: Option<[f32; 3]>,
82    /// 3x1 vector which is used by root presenter as an offset added to the multiplied result
83    /// of |color_adjustment_matrix| and original RGB color. This field should always be set.
84    pub color_adjustment_post_offset: Option<[f32; 3]>,
85    #[doc(hidden)]
86    pub __source_breaking: fidl::marker::SourceBreaking,
87}
88
89impl fidl::Persistable for ColorTransformConfiguration {}
90
91mod internal {
92    use super::*;
93    unsafe impl fidl::encoding::TypeMarker for ColorCorrectionMode {
94        type Owned = Self;
95
96        #[inline(always)]
97        fn inline_align(_context: fidl::encoding::Context) -> usize {
98            std::mem::align_of::<u32>()
99        }
100
101        #[inline(always)]
102        fn inline_size(_context: fidl::encoding::Context) -> usize {
103            std::mem::size_of::<u32>()
104        }
105
106        #[inline(always)]
107        fn encode_is_copy() -> bool {
108            true
109        }
110
111        #[inline(always)]
112        fn decode_is_copy() -> bool {
113            false
114        }
115    }
116
117    impl fidl::encoding::ValueTypeMarker for ColorCorrectionMode {
118        type Borrowed<'a> = Self;
119        #[inline(always)]
120        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
121            *value
122        }
123    }
124
125    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
126        for ColorCorrectionMode
127    {
128        #[inline]
129        unsafe fn encode(
130            self,
131            encoder: &mut fidl::encoding::Encoder<'_, D>,
132            offset: usize,
133            _depth: fidl::encoding::Depth,
134        ) -> fidl::Result<()> {
135            encoder.debug_check_bounds::<Self>(offset);
136            encoder.write_num(self.into_primitive(), offset);
137            Ok(())
138        }
139    }
140
141    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorCorrectionMode {
142        #[inline(always)]
143        fn new_empty() -> Self {
144            Self::Disabled
145        }
146
147        #[inline]
148        unsafe fn decode(
149            &mut self,
150            decoder: &mut fidl::encoding::Decoder<'_, D>,
151            offset: usize,
152            _depth: fidl::encoding::Depth,
153        ) -> fidl::Result<()> {
154            decoder.debug_check_bounds::<Self>(offset);
155            let prim = decoder.read_num::<u32>(offset);
156
157            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
158            Ok(())
159        }
160    }
161
162    impl fidl::encoding::ValueTypeMarker
163        for ColorTransformHandlerSetColorTransformConfigurationRequest
164    {
165        type Borrowed<'a> = &'a Self;
166        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
167            value
168        }
169    }
170
171    unsafe impl fidl::encoding::TypeMarker
172        for ColorTransformHandlerSetColorTransformConfigurationRequest
173    {
174        type Owned = Self;
175
176        #[inline(always)]
177        fn inline_align(_context: fidl::encoding::Context) -> usize {
178            8
179        }
180
181        #[inline(always)]
182        fn inline_size(_context: fidl::encoding::Context) -> usize {
183            16
184        }
185    }
186
187    unsafe impl<D: fidl::encoding::ResourceDialect>
188        fidl::encoding::Encode<ColorTransformHandlerSetColorTransformConfigurationRequest, D>
189        for &ColorTransformHandlerSetColorTransformConfigurationRequest
190    {
191        #[inline]
192        unsafe fn encode(
193            self,
194            encoder: &mut fidl::encoding::Encoder<'_, D>,
195            offset: usize,
196            _depth: fidl::encoding::Depth,
197        ) -> fidl::Result<()> {
198            encoder
199                .debug_check_bounds::<ColorTransformHandlerSetColorTransformConfigurationRequest>(
200                    offset,
201                );
202            // Delegate to tuple encoding.
203            fidl::encoding::Encode::<ColorTransformHandlerSetColorTransformConfigurationRequest, D>::encode(
204                (
205                    <ColorTransformConfiguration as fidl::encoding::ValueTypeMarker>::borrow(&self.configuration),
206                ),
207                encoder, offset, _depth
208            )
209        }
210    }
211    unsafe impl<
212            D: fidl::encoding::ResourceDialect,
213            T0: fidl::encoding::Encode<ColorTransformConfiguration, D>,
214        > fidl::encoding::Encode<ColorTransformHandlerSetColorTransformConfigurationRequest, D>
215        for (T0,)
216    {
217        #[inline]
218        unsafe fn encode(
219            self,
220            encoder: &mut fidl::encoding::Encoder<'_, D>,
221            offset: usize,
222            depth: fidl::encoding::Depth,
223        ) -> fidl::Result<()> {
224            encoder
225                .debug_check_bounds::<ColorTransformHandlerSetColorTransformConfigurationRequest>(
226                    offset,
227                );
228            // Zero out padding regions. There's no need to apply masks
229            // because the unmasked parts will be overwritten by fields.
230            // Write the fields.
231            self.0.encode(encoder, offset + 0, depth)?;
232            Ok(())
233        }
234    }
235
236    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
237        for ColorTransformHandlerSetColorTransformConfigurationRequest
238    {
239        #[inline(always)]
240        fn new_empty() -> Self {
241            Self { configuration: fidl::new_empty!(ColorTransformConfiguration, D) }
242        }
243
244        #[inline]
245        unsafe fn decode(
246            &mut self,
247            decoder: &mut fidl::encoding::Decoder<'_, D>,
248            offset: usize,
249            _depth: fidl::encoding::Depth,
250        ) -> fidl::Result<()> {
251            decoder.debug_check_bounds::<Self>(offset);
252            // Verify that padding bytes are zero.
253            fidl::decode!(
254                ColorTransformConfiguration,
255                D,
256                &mut self.configuration,
257                decoder,
258                offset + 0,
259                _depth
260            )?;
261            Ok(())
262        }
263    }
264
265    impl fidl::encoding::ValueTypeMarker for MagnificationHandlerSetClipSpaceTransformRequest {
266        type Borrowed<'a> = &'a Self;
267        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
268            value
269        }
270    }
271
272    unsafe impl fidl::encoding::TypeMarker for MagnificationHandlerSetClipSpaceTransformRequest {
273        type Owned = Self;
274
275        #[inline(always)]
276        fn inline_align(_context: fidl::encoding::Context) -> usize {
277            4
278        }
279
280        #[inline(always)]
281        fn inline_size(_context: fidl::encoding::Context) -> usize {
282            12
283        }
284    }
285
286    unsafe impl<D: fidl::encoding::ResourceDialect>
287        fidl::encoding::Encode<MagnificationHandlerSetClipSpaceTransformRequest, D>
288        for &MagnificationHandlerSetClipSpaceTransformRequest
289    {
290        #[inline]
291        unsafe fn encode(
292            self,
293            encoder: &mut fidl::encoding::Encoder<'_, D>,
294            offset: usize,
295            _depth: fidl::encoding::Depth,
296        ) -> fidl::Result<()> {
297            encoder.debug_check_bounds::<MagnificationHandlerSetClipSpaceTransformRequest>(offset);
298            // Delegate to tuple encoding.
299            fidl::encoding::Encode::<MagnificationHandlerSetClipSpaceTransformRequest, D>::encode(
300                (
301                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.x),
302                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.y),
303                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.scale),
304                ),
305                encoder,
306                offset,
307                _depth,
308            )
309        }
310    }
311    unsafe impl<
312            D: fidl::encoding::ResourceDialect,
313            T0: fidl::encoding::Encode<f32, D>,
314            T1: fidl::encoding::Encode<f32, D>,
315            T2: fidl::encoding::Encode<f32, D>,
316        > fidl::encoding::Encode<MagnificationHandlerSetClipSpaceTransformRequest, D>
317        for (T0, T1, T2)
318    {
319        #[inline]
320        unsafe fn encode(
321            self,
322            encoder: &mut fidl::encoding::Encoder<'_, D>,
323            offset: usize,
324            depth: fidl::encoding::Depth,
325        ) -> fidl::Result<()> {
326            encoder.debug_check_bounds::<MagnificationHandlerSetClipSpaceTransformRequest>(offset);
327            // Zero out padding regions. There's no need to apply masks
328            // because the unmasked parts will be overwritten by fields.
329            // Write the fields.
330            self.0.encode(encoder, offset + 0, depth)?;
331            self.1.encode(encoder, offset + 4, depth)?;
332            self.2.encode(encoder, offset + 8, depth)?;
333            Ok(())
334        }
335    }
336
337    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
338        for MagnificationHandlerSetClipSpaceTransformRequest
339    {
340        #[inline(always)]
341        fn new_empty() -> Self {
342            Self {
343                x: fidl::new_empty!(f32, D),
344                y: fidl::new_empty!(f32, D),
345                scale: fidl::new_empty!(f32, D),
346            }
347        }
348
349        #[inline]
350        unsafe fn decode(
351            &mut self,
352            decoder: &mut fidl::encoding::Decoder<'_, D>,
353            offset: usize,
354            _depth: fidl::encoding::Depth,
355        ) -> fidl::Result<()> {
356            decoder.debug_check_bounds::<Self>(offset);
357            // Verify that padding bytes are zero.
358            fidl::decode!(f32, D, &mut self.x, decoder, offset + 0, _depth)?;
359            fidl::decode!(f32, D, &mut self.y, decoder, offset + 4, _depth)?;
360            fidl::decode!(f32, D, &mut self.scale, decoder, offset + 8, _depth)?;
361            Ok(())
362        }
363    }
364
365    impl ColorTransformConfiguration {
366        #[inline(always)]
367        fn max_ordinal_present(&self) -> u64 {
368            if let Some(_) = self.color_adjustment_post_offset {
369                return 5;
370            }
371            if let Some(_) = self.color_adjustment_pre_offset {
372                return 4;
373            }
374            if let Some(_) = self.color_adjustment_matrix {
375                return 3;
376            }
377            if let Some(_) = self.color_correction {
378                return 2;
379            }
380            if let Some(_) = self.color_inversion_enabled {
381                return 1;
382            }
383            0
384        }
385    }
386
387    impl fidl::encoding::ValueTypeMarker for ColorTransformConfiguration {
388        type Borrowed<'a> = &'a Self;
389        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
390            value
391        }
392    }
393
394    unsafe impl fidl::encoding::TypeMarker for ColorTransformConfiguration {
395        type Owned = Self;
396
397        #[inline(always)]
398        fn inline_align(_context: fidl::encoding::Context) -> usize {
399            8
400        }
401
402        #[inline(always)]
403        fn inline_size(_context: fidl::encoding::Context) -> usize {
404            16
405        }
406    }
407
408    unsafe impl<D: fidl::encoding::ResourceDialect>
409        fidl::encoding::Encode<ColorTransformConfiguration, D> for &ColorTransformConfiguration
410    {
411        unsafe fn encode(
412            self,
413            encoder: &mut fidl::encoding::Encoder<'_, D>,
414            offset: usize,
415            mut depth: fidl::encoding::Depth,
416        ) -> fidl::Result<()> {
417            encoder.debug_check_bounds::<ColorTransformConfiguration>(offset);
418            // Vector header
419            let max_ordinal: u64 = self.max_ordinal_present();
420            encoder.write_num(max_ordinal, offset);
421            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
422            // Calling encoder.out_of_line_offset(0) is not allowed.
423            if max_ordinal == 0 {
424                return Ok(());
425            }
426            depth.increment()?;
427            let envelope_size = 8;
428            let bytes_len = max_ordinal as usize * envelope_size;
429            #[allow(unused_variables)]
430            let offset = encoder.out_of_line_offset(bytes_len);
431            let mut _prev_end_offset: usize = 0;
432            if 1 > max_ordinal {
433                return Ok(());
434            }
435
436            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
437            // are envelope_size bytes.
438            let cur_offset: usize = (1 - 1) * envelope_size;
439
440            // Zero reserved fields.
441            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
442
443            // Safety:
444            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
445            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
446            //   envelope_size bytes, there is always sufficient room.
447            fidl::encoding::encode_in_envelope_optional::<bool, D>(
448                self.color_inversion_enabled
449                    .as_ref()
450                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
451                encoder,
452                offset + cur_offset,
453                depth,
454            )?;
455
456            _prev_end_offset = cur_offset + envelope_size;
457            if 2 > max_ordinal {
458                return Ok(());
459            }
460
461            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
462            // are envelope_size bytes.
463            let cur_offset: usize = (2 - 1) * envelope_size;
464
465            // Zero reserved fields.
466            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
467
468            // Safety:
469            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
470            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
471            //   envelope_size bytes, there is always sufficient room.
472            fidl::encoding::encode_in_envelope_optional::<ColorCorrectionMode, D>(
473                self.color_correction
474                    .as_ref()
475                    .map(<ColorCorrectionMode as fidl::encoding::ValueTypeMarker>::borrow),
476                encoder,
477                offset + cur_offset,
478                depth,
479            )?;
480
481            _prev_end_offset = cur_offset + envelope_size;
482            if 3 > max_ordinal {
483                return Ok(());
484            }
485
486            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
487            // are envelope_size bytes.
488            let cur_offset: usize = (3 - 1) * envelope_size;
489
490            // Zero reserved fields.
491            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
492
493            // Safety:
494            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
495            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
496            //   envelope_size bytes, there is always sufficient room.
497            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 9>, D>(
498                self.color_adjustment_matrix.as_ref().map(
499                    <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow,
500                ),
501                encoder,
502                offset + cur_offset,
503                depth,
504            )?;
505
506            _prev_end_offset = cur_offset + envelope_size;
507            if 4 > max_ordinal {
508                return Ok(());
509            }
510
511            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
512            // are envelope_size bytes.
513            let cur_offset: usize = (4 - 1) * envelope_size;
514
515            // Zero reserved fields.
516            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
517
518            // Safety:
519            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
520            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
521            //   envelope_size bytes, there is always sufficient room.
522            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 3>, D>(
523                self.color_adjustment_pre_offset.as_ref().map(
524                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
525                ),
526                encoder,
527                offset + cur_offset,
528                depth,
529            )?;
530
531            _prev_end_offset = cur_offset + envelope_size;
532            if 5 > max_ordinal {
533                return Ok(());
534            }
535
536            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
537            // are envelope_size bytes.
538            let cur_offset: usize = (5 - 1) * envelope_size;
539
540            // Zero reserved fields.
541            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
542
543            // Safety:
544            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
545            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
546            //   envelope_size bytes, there is always sufficient room.
547            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<f32, 3>, D>(
548                self.color_adjustment_post_offset.as_ref().map(
549                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
550                ),
551                encoder,
552                offset + cur_offset,
553                depth,
554            )?;
555
556            _prev_end_offset = cur_offset + envelope_size;
557
558            Ok(())
559        }
560    }
561
562    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
563        for ColorTransformConfiguration
564    {
565        #[inline(always)]
566        fn new_empty() -> Self {
567            Self::default()
568        }
569
570        unsafe fn decode(
571            &mut self,
572            decoder: &mut fidl::encoding::Decoder<'_, D>,
573            offset: usize,
574            mut depth: fidl::encoding::Depth,
575        ) -> fidl::Result<()> {
576            decoder.debug_check_bounds::<Self>(offset);
577            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
578                None => return Err(fidl::Error::NotNullable),
579                Some(len) => len,
580            };
581            // Calling decoder.out_of_line_offset(0) is not allowed.
582            if len == 0 {
583                return Ok(());
584            };
585            depth.increment()?;
586            let envelope_size = 8;
587            let bytes_len = len * envelope_size;
588            let offset = decoder.out_of_line_offset(bytes_len)?;
589            // Decode the envelope for each type.
590            let mut _next_ordinal_to_read = 0;
591            let mut next_offset = offset;
592            let end_offset = offset + bytes_len;
593            _next_ordinal_to_read += 1;
594            if next_offset >= end_offset {
595                return Ok(());
596            }
597
598            // Decode unknown envelopes for gaps in ordinals.
599            while _next_ordinal_to_read < 1 {
600                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
601                _next_ordinal_to_read += 1;
602                next_offset += envelope_size;
603            }
604
605            let next_out_of_line = decoder.next_out_of_line();
606            let handles_before = decoder.remaining_handles();
607            if let Some((inlined, num_bytes, num_handles)) =
608                fidl::encoding::decode_envelope_header(decoder, next_offset)?
609            {
610                let member_inline_size =
611                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
612                if inlined != (member_inline_size <= 4) {
613                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
614                }
615                let inner_offset;
616                let mut inner_depth = depth.clone();
617                if inlined {
618                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
619                    inner_offset = next_offset;
620                } else {
621                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
622                    inner_depth.increment()?;
623                }
624                let val_ref =
625                    self.color_inversion_enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
626                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
627                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
628                {
629                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
630                }
631                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
632                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
633                }
634            }
635
636            next_offset += envelope_size;
637            _next_ordinal_to_read += 1;
638            if next_offset >= end_offset {
639                return Ok(());
640            }
641
642            // Decode unknown envelopes for gaps in ordinals.
643            while _next_ordinal_to_read < 2 {
644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
645                _next_ordinal_to_read += 1;
646                next_offset += envelope_size;
647            }
648
649            let next_out_of_line = decoder.next_out_of_line();
650            let handles_before = decoder.remaining_handles();
651            if let Some((inlined, num_bytes, num_handles)) =
652                fidl::encoding::decode_envelope_header(decoder, next_offset)?
653            {
654                let member_inline_size =
655                    <ColorCorrectionMode as fidl::encoding::TypeMarker>::inline_size(
656                        decoder.context,
657                    );
658                if inlined != (member_inline_size <= 4) {
659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
660                }
661                let inner_offset;
662                let mut inner_depth = depth.clone();
663                if inlined {
664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
665                    inner_offset = next_offset;
666                } else {
667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
668                    inner_depth.increment()?;
669                }
670                let val_ref = self
671                    .color_correction
672                    .get_or_insert_with(|| fidl::new_empty!(ColorCorrectionMode, D));
673                fidl::decode!(ColorCorrectionMode, D, val_ref, decoder, inner_offset, inner_depth)?;
674                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
675                {
676                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
677                }
678                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
679                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
680                }
681            }
682
683            next_offset += envelope_size;
684            _next_ordinal_to_read += 1;
685            if next_offset >= end_offset {
686                return Ok(());
687            }
688
689            // Decode unknown envelopes for gaps in ordinals.
690            while _next_ordinal_to_read < 3 {
691                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
692                _next_ordinal_to_read += 1;
693                next_offset += envelope_size;
694            }
695
696            let next_out_of_line = decoder.next_out_of_line();
697            let handles_before = decoder.remaining_handles();
698            if let Some((inlined, num_bytes, num_handles)) =
699                fidl::encoding::decode_envelope_header(decoder, next_offset)?
700            {
701                let member_inline_size =
702                    <fidl::encoding::Array<f32, 9> as fidl::encoding::TypeMarker>::inline_size(
703                        decoder.context,
704                    );
705                if inlined != (member_inline_size <= 4) {
706                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
707                }
708                let inner_offset;
709                let mut inner_depth = depth.clone();
710                if inlined {
711                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
712                    inner_offset = next_offset;
713                } else {
714                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
715                    inner_depth.increment()?;
716                }
717                let val_ref = self
718                    .color_adjustment_matrix
719                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 9>, D));
720                fidl::decode!(fidl::encoding::Array<f32, 9>, D, val_ref, decoder, inner_offset, inner_depth)?;
721                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
722                {
723                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
724                }
725                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
726                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
727                }
728            }
729
730            next_offset += envelope_size;
731            _next_ordinal_to_read += 1;
732            if next_offset >= end_offset {
733                return Ok(());
734            }
735
736            // Decode unknown envelopes for gaps in ordinals.
737            while _next_ordinal_to_read < 4 {
738                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
739                _next_ordinal_to_read += 1;
740                next_offset += envelope_size;
741            }
742
743            let next_out_of_line = decoder.next_out_of_line();
744            let handles_before = decoder.remaining_handles();
745            if let Some((inlined, num_bytes, num_handles)) =
746                fidl::encoding::decode_envelope_header(decoder, next_offset)?
747            {
748                let member_inline_size =
749                    <fidl::encoding::Array<f32, 3> as fidl::encoding::TypeMarker>::inline_size(
750                        decoder.context,
751                    );
752                if inlined != (member_inline_size <= 4) {
753                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
754                }
755                let inner_offset;
756                let mut inner_depth = depth.clone();
757                if inlined {
758                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
759                    inner_offset = next_offset;
760                } else {
761                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
762                    inner_depth.increment()?;
763                }
764                let val_ref = self
765                    .color_adjustment_pre_offset
766                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 3>, D));
767                fidl::decode!(fidl::encoding::Array<f32, 3>, D, val_ref, decoder, inner_offset, inner_depth)?;
768                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
769                {
770                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
771                }
772                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
773                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
774                }
775            }
776
777            next_offset += envelope_size;
778            _next_ordinal_to_read += 1;
779            if next_offset >= end_offset {
780                return Ok(());
781            }
782
783            // Decode unknown envelopes for gaps in ordinals.
784            while _next_ordinal_to_read < 5 {
785                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
786                _next_ordinal_to_read += 1;
787                next_offset += envelope_size;
788            }
789
790            let next_out_of_line = decoder.next_out_of_line();
791            let handles_before = decoder.remaining_handles();
792            if let Some((inlined, num_bytes, num_handles)) =
793                fidl::encoding::decode_envelope_header(decoder, next_offset)?
794            {
795                let member_inline_size =
796                    <fidl::encoding::Array<f32, 3> as fidl::encoding::TypeMarker>::inline_size(
797                        decoder.context,
798                    );
799                if inlined != (member_inline_size <= 4) {
800                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
801                }
802                let inner_offset;
803                let mut inner_depth = depth.clone();
804                if inlined {
805                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
806                    inner_offset = next_offset;
807                } else {
808                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
809                    inner_depth.increment()?;
810                }
811                let val_ref = self
812                    .color_adjustment_post_offset
813                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<f32, 3>, D));
814                fidl::decode!(fidl::encoding::Array<f32, 3>, D, val_ref, decoder, inner_offset, inner_depth)?;
815                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
816                {
817                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
818                }
819                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
820                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
821                }
822            }
823
824            next_offset += envelope_size;
825
826            // Decode the remaining unknown envelopes.
827            while next_offset < end_offset {
828                _next_ordinal_to_read += 1;
829                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
830                next_offset += envelope_size;
831            }
832
833            Ok(())
834        }
835    }
836}