fidl_fuchsia_ui_display_singleton__common/
fidl_fuchsia_ui_display_singleton__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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12pub struct DisplayPowerSetDisplayPowerRequest {
13    pub power_on: bool,
14}
15
16impl fidl::Persistable for DisplayPowerSetDisplayPowerRequest {}
17
18#[derive(Clone, Debug, PartialEq)]
19pub struct InfoGetMetricsResponse {
20    pub info: Metrics,
21}
22
23impl fidl::Persistable for InfoGetMetricsResponse {}
24
25/// Describes the physical display, and how to map between physical and logical pixels.
26#[derive(Clone, Debug, Default, PartialEq)]
27pub struct Metrics {
28    /// Same meaning as `horizontal_resolution` and `vertical_resolution`
29    /// in `fuchsia.hardware.display.Mode`. Given in physical pixels.
30    pub extent_in_px: Option<fidl_fuchsia_math__common::SizeU>,
31    /// Same meaning as `horizontal_size_mm` and `vertical_size_mm`
32    /// in `fuchsia.hardware.display.Info`.
33    pub extent_in_mm: Option<fidl_fuchsia_math__common::SizeU>,
34    /// The number of physical pixels per "logical" pixel, for example as in
35    /// `fuchsia.ui.composition.LayoutInfo.logical_size`.  It provides an indication
36    /// of the size of image buffers that should be allocated.  This value would typically
37    /// be used by a component near the root of the scene graph to set a scale for the rest
38    /// of the scene beneath.
39    pub recommended_device_pixel_ratio: Option<fidl_fuchsia_math__common::VecF>,
40    /// The maximum mumber of images transmitted to the display in 1000 seconds.
41    /// This is the display's maximum vertical refresh rate, in millihertz (0.001 Hz).
42    pub maximum_refresh_rate_in_millihertz: Option<u32>,
43    #[doc(hidden)]
44    pub __source_breaking: fidl::marker::SourceBreaking,
45}
46
47impl fidl::Persistable for Metrics {}
48
49pub mod display_power_ordinals {
50    pub const SET_DISPLAY_POWER: u64 = 0x59f31b10e74ce66f;
51}
52
53pub mod info_ordinals {
54    pub const GET_METRICS: u64 = 0x6d631353834698be;
55}
56
57mod internal {
58    use super::*;
59
60    impl fidl::encoding::ValueTypeMarker for DisplayPowerSetDisplayPowerRequest {
61        type Borrowed<'a> = &'a Self;
62        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
63            value
64        }
65    }
66
67    unsafe impl fidl::encoding::TypeMarker for DisplayPowerSetDisplayPowerRequest {
68        type Owned = Self;
69
70        #[inline(always)]
71        fn inline_align(_context: fidl::encoding::Context) -> usize {
72            1
73        }
74
75        #[inline(always)]
76        fn inline_size(_context: fidl::encoding::Context) -> usize {
77            1
78        }
79    }
80
81    unsafe impl<D: fidl::encoding::ResourceDialect>
82        fidl::encoding::Encode<DisplayPowerSetDisplayPowerRequest, D>
83        for &DisplayPowerSetDisplayPowerRequest
84    {
85        #[inline]
86        unsafe fn encode(
87            self,
88            encoder: &mut fidl::encoding::Encoder<'_, D>,
89            offset: usize,
90            _depth: fidl::encoding::Depth,
91        ) -> fidl::Result<()> {
92            encoder.debug_check_bounds::<DisplayPowerSetDisplayPowerRequest>(offset);
93            // Delegate to tuple encoding.
94            fidl::encoding::Encode::<DisplayPowerSetDisplayPowerRequest, D>::encode(
95                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.power_on),),
96                encoder,
97                offset,
98                _depth,
99            )
100        }
101    }
102    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
103        fidl::encoding::Encode<DisplayPowerSetDisplayPowerRequest, D> for (T0,)
104    {
105        #[inline]
106        unsafe fn encode(
107            self,
108            encoder: &mut fidl::encoding::Encoder<'_, D>,
109            offset: usize,
110            depth: fidl::encoding::Depth,
111        ) -> fidl::Result<()> {
112            encoder.debug_check_bounds::<DisplayPowerSetDisplayPowerRequest>(offset);
113            // Zero out padding regions. There's no need to apply masks
114            // because the unmasked parts will be overwritten by fields.
115            // Write the fields.
116            self.0.encode(encoder, offset + 0, depth)?;
117            Ok(())
118        }
119    }
120
121    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
122        for DisplayPowerSetDisplayPowerRequest
123    {
124        #[inline(always)]
125        fn new_empty() -> Self {
126            Self { power_on: fidl::new_empty!(bool, D) }
127        }
128
129        #[inline]
130        unsafe fn decode(
131            &mut self,
132            decoder: &mut fidl::encoding::Decoder<'_, D>,
133            offset: usize,
134            _depth: fidl::encoding::Depth,
135        ) -> fidl::Result<()> {
136            decoder.debug_check_bounds::<Self>(offset);
137            // Verify that padding bytes are zero.
138            fidl::decode!(bool, D, &mut self.power_on, decoder, offset + 0, _depth)?;
139            Ok(())
140        }
141    }
142
143    impl fidl::encoding::ValueTypeMarker for InfoGetMetricsResponse {
144        type Borrowed<'a> = &'a Self;
145        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
146            value
147        }
148    }
149
150    unsafe impl fidl::encoding::TypeMarker for InfoGetMetricsResponse {
151        type Owned = Self;
152
153        #[inline(always)]
154        fn inline_align(_context: fidl::encoding::Context) -> usize {
155            8
156        }
157
158        #[inline(always)]
159        fn inline_size(_context: fidl::encoding::Context) -> usize {
160            16
161        }
162    }
163
164    unsafe impl<D: fidl::encoding::ResourceDialect>
165        fidl::encoding::Encode<InfoGetMetricsResponse, D> for &InfoGetMetricsResponse
166    {
167        #[inline]
168        unsafe fn encode(
169            self,
170            encoder: &mut fidl::encoding::Encoder<'_, D>,
171            offset: usize,
172            _depth: fidl::encoding::Depth,
173        ) -> fidl::Result<()> {
174            encoder.debug_check_bounds::<InfoGetMetricsResponse>(offset);
175            // Delegate to tuple encoding.
176            fidl::encoding::Encode::<InfoGetMetricsResponse, D>::encode(
177                (<Metrics as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
178                encoder,
179                offset,
180                _depth,
181            )
182        }
183    }
184    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Metrics, D>>
185        fidl::encoding::Encode<InfoGetMetricsResponse, D> for (T0,)
186    {
187        #[inline]
188        unsafe fn encode(
189            self,
190            encoder: &mut fidl::encoding::Encoder<'_, D>,
191            offset: usize,
192            depth: fidl::encoding::Depth,
193        ) -> fidl::Result<()> {
194            encoder.debug_check_bounds::<InfoGetMetricsResponse>(offset);
195            // Zero out padding regions. There's no need to apply masks
196            // because the unmasked parts will be overwritten by fields.
197            // Write the fields.
198            self.0.encode(encoder, offset + 0, depth)?;
199            Ok(())
200        }
201    }
202
203    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
204        for InfoGetMetricsResponse
205    {
206        #[inline(always)]
207        fn new_empty() -> Self {
208            Self { info: fidl::new_empty!(Metrics, D) }
209        }
210
211        #[inline]
212        unsafe fn decode(
213            &mut self,
214            decoder: &mut fidl::encoding::Decoder<'_, D>,
215            offset: usize,
216            _depth: fidl::encoding::Depth,
217        ) -> fidl::Result<()> {
218            decoder.debug_check_bounds::<Self>(offset);
219            // Verify that padding bytes are zero.
220            fidl::decode!(Metrics, D, &mut self.info, decoder, offset + 0, _depth)?;
221            Ok(())
222        }
223    }
224
225    impl Metrics {
226        #[inline(always)]
227        fn max_ordinal_present(&self) -> u64 {
228            if let Some(_) = self.maximum_refresh_rate_in_millihertz {
229                return 4;
230            }
231            if let Some(_) = self.recommended_device_pixel_ratio {
232                return 3;
233            }
234            if let Some(_) = self.extent_in_mm {
235                return 2;
236            }
237            if let Some(_) = self.extent_in_px {
238                return 1;
239            }
240            0
241        }
242    }
243
244    impl fidl::encoding::ValueTypeMarker for Metrics {
245        type Borrowed<'a> = &'a Self;
246        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
247            value
248        }
249    }
250
251    unsafe impl fidl::encoding::TypeMarker for Metrics {
252        type Owned = Self;
253
254        #[inline(always)]
255        fn inline_align(_context: fidl::encoding::Context) -> usize {
256            8
257        }
258
259        #[inline(always)]
260        fn inline_size(_context: fidl::encoding::Context) -> usize {
261            16
262        }
263    }
264
265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Metrics, D> for &Metrics {
266        unsafe fn encode(
267            self,
268            encoder: &mut fidl::encoding::Encoder<'_, D>,
269            offset: usize,
270            mut depth: fidl::encoding::Depth,
271        ) -> fidl::Result<()> {
272            encoder.debug_check_bounds::<Metrics>(offset);
273            // Vector header
274            let max_ordinal: u64 = self.max_ordinal_present();
275            encoder.write_num(max_ordinal, offset);
276            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
277            // Calling encoder.out_of_line_offset(0) is not allowed.
278            if max_ordinal == 0 {
279                return Ok(());
280            }
281            depth.increment()?;
282            let envelope_size = 8;
283            let bytes_len = max_ordinal as usize * envelope_size;
284            #[allow(unused_variables)]
285            let offset = encoder.out_of_line_offset(bytes_len);
286            let mut _prev_end_offset: usize = 0;
287            if 1 > max_ordinal {
288                return Ok(());
289            }
290
291            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
292            // are envelope_size bytes.
293            let cur_offset: usize = (1 - 1) * envelope_size;
294
295            // Zero reserved fields.
296            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
297
298            // Safety:
299            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
300            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
301            //   envelope_size bytes, there is always sufficient room.
302            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
303                self.extent_in_px.as_ref().map(
304                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
305                ),
306                encoder,
307                offset + cur_offset,
308                depth,
309            )?;
310
311            _prev_end_offset = cur_offset + envelope_size;
312            if 2 > max_ordinal {
313                return Ok(());
314            }
315
316            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
317            // are envelope_size bytes.
318            let cur_offset: usize = (2 - 1) * envelope_size;
319
320            // Zero reserved fields.
321            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
322
323            // Safety:
324            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
325            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
326            //   envelope_size bytes, there is always sufficient room.
327            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
328                self.extent_in_mm.as_ref().map(
329                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
330                ),
331                encoder,
332                offset + cur_offset,
333                depth,
334            )?;
335
336            _prev_end_offset = cur_offset + envelope_size;
337            if 3 > max_ordinal {
338                return Ok(());
339            }
340
341            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
342            // are envelope_size bytes.
343            let cur_offset: usize = (3 - 1) * envelope_size;
344
345            // Zero reserved fields.
346            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
347
348            // Safety:
349            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
350            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
351            //   envelope_size bytes, there is always sufficient room.
352            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::VecF, D>(
353                self.recommended_device_pixel_ratio.as_ref().map(
354                    <fidl_fuchsia_math__common::VecF as fidl::encoding::ValueTypeMarker>::borrow,
355                ),
356                encoder,
357                offset + cur_offset,
358                depth,
359            )?;
360
361            _prev_end_offset = cur_offset + envelope_size;
362            if 4 > max_ordinal {
363                return Ok(());
364            }
365
366            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
367            // are envelope_size bytes.
368            let cur_offset: usize = (4 - 1) * envelope_size;
369
370            // Zero reserved fields.
371            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
372
373            // Safety:
374            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
375            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
376            //   envelope_size bytes, there is always sufficient room.
377            fidl::encoding::encode_in_envelope_optional::<u32, D>(
378                self.maximum_refresh_rate_in_millihertz
379                    .as_ref()
380                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
381                encoder,
382                offset + cur_offset,
383                depth,
384            )?;
385
386            _prev_end_offset = cur_offset + envelope_size;
387
388            Ok(())
389        }
390    }
391
392    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Metrics {
393        #[inline(always)]
394        fn new_empty() -> Self {
395            Self::default()
396        }
397
398        unsafe fn decode(
399            &mut self,
400            decoder: &mut fidl::encoding::Decoder<'_, D>,
401            offset: usize,
402            mut depth: fidl::encoding::Depth,
403        ) -> fidl::Result<()> {
404            decoder.debug_check_bounds::<Self>(offset);
405            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
406                None => return Err(fidl::Error::NotNullable),
407                Some(len) => len,
408            };
409            // Calling decoder.out_of_line_offset(0) is not allowed.
410            if len == 0 {
411                return Ok(());
412            };
413            depth.increment()?;
414            let envelope_size = 8;
415            let bytes_len = len * envelope_size;
416            let offset = decoder.out_of_line_offset(bytes_len)?;
417            // Decode the envelope for each type.
418            let mut _next_ordinal_to_read = 0;
419            let mut next_offset = offset;
420            let end_offset = offset + bytes_len;
421            _next_ordinal_to_read += 1;
422            if next_offset >= end_offset {
423                return Ok(());
424            }
425
426            // Decode unknown envelopes for gaps in ordinals.
427            while _next_ordinal_to_read < 1 {
428                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
429                _next_ordinal_to_read += 1;
430                next_offset += envelope_size;
431            }
432
433            let next_out_of_line = decoder.next_out_of_line();
434            let handles_before = decoder.remaining_handles();
435            if let Some((inlined, num_bytes, num_handles)) =
436                fidl::encoding::decode_envelope_header(decoder, next_offset)?
437            {
438                let member_inline_size =
439                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
440                        decoder.context,
441                    );
442                if inlined != (member_inline_size <= 4) {
443                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
444                }
445                let inner_offset;
446                let mut inner_depth = depth.clone();
447                if inlined {
448                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
449                    inner_offset = next_offset;
450                } else {
451                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
452                    inner_depth.increment()?;
453                }
454                let val_ref = self
455                    .extent_in_px
456                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
457                fidl::decode!(
458                    fidl_fuchsia_math__common::SizeU,
459                    D,
460                    val_ref,
461                    decoder,
462                    inner_offset,
463                    inner_depth
464                )?;
465                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
466                {
467                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
468                }
469                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
470                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
471                }
472            }
473
474            next_offset += envelope_size;
475            _next_ordinal_to_read += 1;
476            if next_offset >= end_offset {
477                return Ok(());
478            }
479
480            // Decode unknown envelopes for gaps in ordinals.
481            while _next_ordinal_to_read < 2 {
482                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
483                _next_ordinal_to_read += 1;
484                next_offset += envelope_size;
485            }
486
487            let next_out_of_line = decoder.next_out_of_line();
488            let handles_before = decoder.remaining_handles();
489            if let Some((inlined, num_bytes, num_handles)) =
490                fidl::encoding::decode_envelope_header(decoder, next_offset)?
491            {
492                let member_inline_size =
493                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
494                        decoder.context,
495                    );
496                if inlined != (member_inline_size <= 4) {
497                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
498                }
499                let inner_offset;
500                let mut inner_depth = depth.clone();
501                if inlined {
502                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
503                    inner_offset = next_offset;
504                } else {
505                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
506                    inner_depth.increment()?;
507                }
508                let val_ref = self
509                    .extent_in_mm
510                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
511                fidl::decode!(
512                    fidl_fuchsia_math__common::SizeU,
513                    D,
514                    val_ref,
515                    decoder,
516                    inner_offset,
517                    inner_depth
518                )?;
519                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
520                {
521                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
522                }
523                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
524                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
525                }
526            }
527
528            next_offset += envelope_size;
529            _next_ordinal_to_read += 1;
530            if next_offset >= end_offset {
531                return Ok(());
532            }
533
534            // Decode unknown envelopes for gaps in ordinals.
535            while _next_ordinal_to_read < 3 {
536                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
537                _next_ordinal_to_read += 1;
538                next_offset += envelope_size;
539            }
540
541            let next_out_of_line = decoder.next_out_of_line();
542            let handles_before = decoder.remaining_handles();
543            if let Some((inlined, num_bytes, num_handles)) =
544                fidl::encoding::decode_envelope_header(decoder, next_offset)?
545            {
546                let member_inline_size =
547                    <fidl_fuchsia_math__common::VecF as fidl::encoding::TypeMarker>::inline_size(
548                        decoder.context,
549                    );
550                if inlined != (member_inline_size <= 4) {
551                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
552                }
553                let inner_offset;
554                let mut inner_depth = depth.clone();
555                if inlined {
556                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
557                    inner_offset = next_offset;
558                } else {
559                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
560                    inner_depth.increment()?;
561                }
562                let val_ref = self
563                    .recommended_device_pixel_ratio
564                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::VecF, D));
565                fidl::decode!(
566                    fidl_fuchsia_math__common::VecF,
567                    D,
568                    val_ref,
569                    decoder,
570                    inner_offset,
571                    inner_depth
572                )?;
573                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
574                {
575                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
576                }
577                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
578                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
579                }
580            }
581
582            next_offset += envelope_size;
583            _next_ordinal_to_read += 1;
584            if next_offset >= end_offset {
585                return Ok(());
586            }
587
588            // Decode unknown envelopes for gaps in ordinals.
589            while _next_ordinal_to_read < 4 {
590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591                _next_ordinal_to_read += 1;
592                next_offset += envelope_size;
593            }
594
595            let next_out_of_line = decoder.next_out_of_line();
596            let handles_before = decoder.remaining_handles();
597            if let Some((inlined, num_bytes, num_handles)) =
598                fidl::encoding::decode_envelope_header(decoder, next_offset)?
599            {
600                let member_inline_size =
601                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
602                if inlined != (member_inline_size <= 4) {
603                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
604                }
605                let inner_offset;
606                let mut inner_depth = depth.clone();
607                if inlined {
608                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
609                    inner_offset = next_offset;
610                } else {
611                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
612                    inner_depth.increment()?;
613                }
614                let val_ref = self
615                    .maximum_refresh_rate_in_millihertz
616                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
617                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
618                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
619                {
620                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
621                }
622                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
623                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
624                }
625            }
626
627            next_offset += envelope_size;
628
629            // Decode the remaining unknown envelopes.
630            while next_offset < end_offset {
631                _next_ordinal_to_read += 1;
632                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
633                next_offset += envelope_size;
634            }
635
636            Ok(())
637        }
638    }
639}