1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13#[repr(u32)]
14pub enum ColorCorrectionMode {
15 Disabled = 0,
17 CorrectProtanomaly = 1,
19 CorrectDeuteranomaly = 2,
21 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#[derive(Clone, Debug, Default, PartialEq)]
68pub struct ColorTransformConfiguration {
69 pub color_inversion_enabled: Option<bool>,
72 pub color_correction: Option<ColorCorrectionMode>,
76 pub color_adjustment_matrix: Option<[f32; 9]>,
79 pub color_adjustment_pre_offset: Option<[f32; 3]>,
82 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
439
440 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
442
443 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 let cur_offset: usize = (2 - 1) * envelope_size;
464
465 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
467
468 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 let cur_offset: usize = (3 - 1) * envelope_size;
489
490 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
492
493 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 let cur_offset: usize = (4 - 1) * envelope_size;
514
515 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
517
518 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 let cur_offset: usize = (5 - 1) * envelope_size;
539
540 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
542
543 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 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 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 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 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 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 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 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 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}