fidl_fuchsia_images2/

fidl_fuchsia_images2.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub const FORMAT_MODIFIER_ARM_BCH_BIT: u64 = 2048;

pub const FORMAT_MODIFIER_ARM_SPARSE_BIT: u64 = 64;

pub const FORMAT_MODIFIER_ARM_SPLIT_BLOCK_BIT: u64 = 32;

pub const FORMAT_MODIFIER_ARM_TE_BIT: u64 = 4096;

pub const FORMAT_MODIFIER_ARM_TILED_HEADER_BIT: u64 = 8192;

pub const FORMAT_MODIFIER_ARM_YUV_BIT: u64 = 16;

/// Format has a color control surface after the tile data
pub const FORMAT_MODIFIER_INTEL_CCS_BIT: u64 = 16777216;

pub const FORMAT_MODIFIER_VENDOR_ALLWINNER: u64 = 648518346341351424;

pub const FORMAT_MODIFIER_VENDOR_AMD: u64 = 144115188075855872;

pub const FORMAT_MODIFIER_VENDOR_AMLOGIC: u64 = 720575940379279360;

pub const FORMAT_MODIFIER_VENDOR_ARM: u64 = 576460752303423488;

pub const FORMAT_MODIFIER_VENDOR_BROADCOM: u64 = 504403158265495552;

pub const FORMAT_MODIFIER_VENDOR_GOOGLE: u64 = 7421932185906577408;

pub const FORMAT_MODIFIER_VENDOR_INTEL: u64 = 72057594037927936;

pub const FORMAT_MODIFIER_VENDOR_NVIDIA: u64 = 216172782113783808;

pub const FORMAT_MODIFIER_VENDOR_QCOM: u64 = 360287970189639680;

pub const FORMAT_MODIFIER_VENDOR_SAMSUNG: u64 = 288230376151711744;

pub const FORMAT_MODIFIER_VENDOR_VIVANTE: u64 = 432345564227567616;

/// Expresses the color space used to interpret video pixel values.
///
/// This list has a separate entry for each variant of a color space standard.
///
/// For this reason, should we ever add support for the RGB variant of 709, for
/// example, we'd add a separate entry to this list for that variant.  Similarly
/// for the RGB variants of 2020 or 2100.  Similarly for the YcCbcCrc variant of
/// 2020.  Similarly for the ICtCp variant of 2100.
///
/// See ImageFormatIsSupportedColorSpaceForPixelFormat() for whether a
/// combination of `PixelFormat` and `ColorSpace` is potentially supported.
///
/// Generally, a `ColorSpace` is not supported for any `PixelFormat` whose
/// bits-per-sample isn't compatible with the color space's spec, nor for any
/// `PixelFormat` which is a mismatch in terms of RGB vs. YUV.
///
/// The "limited range" in comments below refers to where black and white are
/// defined to be (and simimlar for chroma), but should not be interpreted as
/// guaranteeing that there won't be values outside the nominal "limited range".
/// In other words, "limited range" doesn't necessarily mean there won't be any
/// values below black or above white, or outside the "limited" chroma range.
/// For "full range", black is 0 and white is the max possible/permitted numeric
/// value (and similar for chroma).
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ColorSpace {
    /// Not a valid color space type.
    Invalid,
    /// sRGB, gamma transfer function and full range, per spec
    Srgb,
    /// 601 NTSC ("525 line") YCbCr primaries, limited range
    Rec601Ntsc,
    /// 601 NTSC ("525 line") YCbCr primaries, full range
    Rec601NtscFullRange,
    /// 601 PAL ("625 line") YCbCr primaries, limited range
    Rec601Pal,
    /// 601 PAL ("625 line") YCbCr primaries, full range
    Rec601PalFullRange,
    /// 709 YCbCr (not RGB), limited range
    Rec709,
    /// 2020 YCbCr (not RGB, not YcCbcCrc), 10 or 12 bit according to
    /// `PixelFormat`, with primaries, limited range (not full range), transfer
    /// function ("gamma"), etc all per spec, wide color gamut SDR
    Rec2020,
    /// 2100 YCbCr (not RGB, not ICtCp), 10 or 12 bit according to
    /// `PixelFormat`, BT.2020 primaries (same wide color gamut as REC2020),
    /// limited range (not full range), PQ (aka SMPTE ST 2084) HDR transfer
    /// function (not HLG, not SDR "gamma" used by REC2020 and REC709), wide
    /// color gamut HDR
    Rec2100,
    /// Either the pixel format doesn't represent a color, or it's in an
    /// application-specific colorspace that isn't describable by another entry
    /// in this enum.
    Passthrough,
    /// A client is explicitly indicating that the client does not care which
    /// color space is chosen / used.
    DoNotCare,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `ColorSpace` member.
#[macro_export]
macro_rules! ColorSpaceUnknown {
    () => {
        _
    };
}

impl ColorSpace {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Invalid),
            1 => Some(Self::Srgb),
            2 => Some(Self::Rec601Ntsc),
            3 => Some(Self::Rec601NtscFullRange),
            4 => Some(Self::Rec601Pal),
            5 => Some(Self::Rec601PalFullRange),
            6 => Some(Self::Rec709),
            7 => Some(Self::Rec2020),
            8 => Some(Self::Rec2100),
            9 => Some(Self::Passthrough),
            4294967294 => Some(Self::DoNotCare),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::Invalid,
            1 => Self::Srgb,
            2 => Self::Rec601Ntsc,
            3 => Self::Rec601NtscFullRange,
            4 => Self::Rec601Pal,
            5 => Self::Rec601PalFullRange,
            6 => Self::Rec709,
            7 => Self::Rec2020,
            8 => Self::Rec2100,
            9 => Self::Passthrough,
            4294967294 => Self::DoNotCare,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Invalid => 0,
            Self::Srgb => 1,
            Self::Rec601Ntsc => 2,
            Self::Rec601NtscFullRange => 3,
            Self::Rec601Pal => 4,
            Self::Rec601PalFullRange => 5,
            Self::Rec709 => 6,
            Self::Rec2020 => 7,
            Self::Rec2100 => 8,
            Self::Passthrough => 9,
            Self::DoNotCare => 4294967294,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// Expresses the manner in which video pixels are encoded.
///
/// The ordering of the channels in the format name reflects the actual layout
/// of the channel.
///
/// Each of these values is opinionated re. the color spaces that should be
/// contained within (in contrast with Vulkan).
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum PixelFormat {
    Invalid,
    /// RGB only, 8 bits per each of R/G/B/A sample
    ///
    /// If A is actually X (not set to meaningful values), that can be specified
    /// by settting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present']
    /// to false.
    ///
    /// If A is known to be set to meaningful values, that can be specified by
    /// setting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] to
    /// true.
    ///
    /// Compatible with VK_FORMAT_R8G8B8A8_UNORM.
    R8G8B8A8,
    /// RGB only, 8 bits per each of R/G/B/X sample
    ///
    /// Compatible with VK_FORMAT_R8G8B8A8_UNORM, when treated as opaque.
    ///
    /// Deprecated. Use `R8G8B8A8` with
    /// ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] set to false
    /// instead.
    R8G8B8X8,
    /// 32bpp BGRA, 1 plane.  RGB only, 8 bits per each of B/G/R/A sample.
    ///
    /// Compatible with VK_FORMAT_B8G8R8A8_UNORM.
    ///
    /// If A is actually X (not set to meaningful values), that can be specified
    /// by settting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present']
    /// to false.
    ///
    /// If A is known to be set to meaningful values, that can be specified by
    /// setting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] to
    /// true.
    ///
    /// In sysmem(1), this is BGRA32.
    B8G8R8A8,
    /// 32bpp BGRA, 1 plane.  RGB only, 8 bits per each of B/G/R/X sample.
    ///
    /// Compatible with VK_FORMAT_B8G8R8A8_UNORM, when treated as opaque.
    ///
    /// Deprecated. Use `B8G8R8A8` with
    /// [`fuchsia.sysemm2/ImageFormatConstraints.is_alpha_present`] set to false
    /// instead.
    B8G8R8X8,
    /// YUV only, 8 bits per Y sample
    ///
    /// Compatible with VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM.
    I420,
    /// YUV only, 8 bits per Y sample
    ///
    /// Not compatible with any vulkan format.
    M420,
    /// YUV only, 8 bits per Y sample
    ///
    /// Compatible with VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
    Nv12,
    /// YUV only, 8 bits per Y sample
    ///
    /// Compatible with VK_FORMAT_G8B8G8R8_422_UNORM.
    Yuy2,
    /// This value is reserved, and not currently used.
    Mjpeg,
    /// YUV only, 8 bits per Y sample
    ///
    /// Compatible with VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM. The U plane may be located in either
    /// the B or R plane for the image (and likewise for the V plane); the ordering may be
    /// determined by looking at the members of
    /// `VkBufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents`.
    Yv12,
    /// 24bpp BGR, 1 plane. RGB only, 8 bits per each of B/G/R sample
    ///
    /// Compatible with VK_FORMAT_B8G8R8_UNORM.
    ///
    /// In sysmem(1), this is BGR24.
    B8G8R8,
    /// 16bpp RGB, 1 plane. 5 bits R, 6 bits G, 5 bits B
    ///
    /// Compatible with VK_FORMAT_R5G6B5_UNORM_PACK16.
    ///
    /// In sysmem(1), this is RGB565.
    R5G6B5,
    /// 8bpp RGB, 1 plane. 3 bits R, 3 bits G, 2 bits B
    ///
    /// Not compatible with any vulkan format.
    ///
    /// In sysmem(1), this is RGB332.
    R3G3B2,
    /// 8bpp RGB, 1 plane. 2 bits R, 2 bits G, 2 bits B
    ///
    /// Not compatible with any vulkan format.
    ///
    /// If X is actually X (not set to meaningful values), that can be specified
    /// by settting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present']
    /// to false.
    ///
    /// If X is known to be set to meaningful values, that can be specified by
    /// setting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] to
    /// true.
    ///
    /// In sysmem(1), this is RGB2220.
    R2G2B2X2,
    /// 8bpp, Luminance-only (red, green and blue have identical values.)
    ///
    /// Compatible with VK_FORMAT_R8_UNORM.
    ///
    /// Most clients will prefer to use R8 instead.
    L8,
    /// 8bpp, Red-only (Green and Blue are to be interpreted as 0).
    ///
    /// Compatible with VK_FORMAT_R8_UNORM.
    R8,
    /// 16bpp RG, 1 plane. 8 bits R, 8 bits G.
    ///
    /// Compatible with VK_FORMAT_R8G8_UNORM.
    R8G8,
    /// 32bpp RGBA, 1 plane. 2 bits A, 10 bits R/G/B.
    ///
    /// If A is actually X (not set to meaningful values), that can be specified
    /// by settting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present']
    /// to false.
    ///
    /// If A is known to be set to meaningful values, that can be specified by
    /// setting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] to
    /// true.
    ///
    /// Compatible with VK_FORMAT_A2R10G10B10_UNORM_PACK32.
    A2R10G10B10,
    /// 32bpp BGRA, 1 plane. 2 bits A, 10 bits R/G/B.
    ///
    /// If A is actually X (not set to meaningful values), that can be specified
    /// by settting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present']
    /// to false.
    ///
    /// If A is known to be set to meaningful values, that can be specified by
    /// setting ['fuchsia.sysemm2.ImageFormatConstraints.is_alpha_present'] to
    /// true.
    ///
    /// Compatible with VK_FORMAT_A2B10G10R10_UNORM_PACK32.
    A2B10G10R10,
    /// YUV only, 16 bits per Y sample
    ///
    /// This is like NV12 but with 16 bit samples that have the bottom 6 bits of
    /// each sample set to zero and/or ignored. The endianess of each 16 bit
    /// sample is host endian-ness (LE on LE system, BE on BE system). The CbCr
    /// plane has 16 bit Cb first, then 16 bit Cr, interleaved Cb Cr Cb Cr etc.
    ///
    /// Compatible with VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16.
    P010,
    /// 24bpp RGB, 1 plane. RGB only, 8 bits per each of R/G/B sample
    ///
    /// Compatible with VK_FORMAT_R8G8B8_UNORM.
    R8G8B8,
    /// A client is explicitly indicating that the client does not care which
    /// pixel format is chosen / used.  When setting this value, the client must
    /// not set `pixel_format_modifier`.
    DoNotCare,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

/// Pattern that matches an unknown `PixelFormat` member.
#[macro_export]
macro_rules! PixelFormatUnknown {
    () => {
        _
    };
}

impl PixelFormat {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Invalid),
            1 => Some(Self::R8G8B8A8),
            119 => Some(Self::R8G8B8X8),
            101 => Some(Self::B8G8R8A8),
            120 => Some(Self::B8G8R8X8),
            102 => Some(Self::I420),
            103 => Some(Self::M420),
            104 => Some(Self::Nv12),
            105 => Some(Self::Yuy2),
            106 => Some(Self::Mjpeg),
            107 => Some(Self::Yv12),
            108 => Some(Self::B8G8R8),
            109 => Some(Self::R5G6B5),
            110 => Some(Self::R3G3B2),
            111 => Some(Self::R2G2B2X2),
            112 => Some(Self::L8),
            113 => Some(Self::R8),
            114 => Some(Self::R8G8),
            115 => Some(Self::A2R10G10B10),
            116 => Some(Self::A2B10G10R10),
            117 => Some(Self::P010),
            118 => Some(Self::R8G8B8),
            4294967294 => Some(Self::DoNotCare),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::Invalid,
            1 => Self::R8G8B8A8,
            119 => Self::R8G8B8X8,
            101 => Self::B8G8R8A8,
            120 => Self::B8G8R8X8,
            102 => Self::I420,
            103 => Self::M420,
            104 => Self::Nv12,
            105 => Self::Yuy2,
            106 => Self::Mjpeg,
            107 => Self::Yv12,
            108 => Self::B8G8R8,
            109 => Self::R5G6B5,
            110 => Self::R3G3B2,
            111 => Self::R2G2B2X2,
            112 => Self::L8,
            113 => Self::R8,
            114 => Self::R8G8,
            115 => Self::A2R10G10B10,
            116 => Self::A2B10G10R10,
            117 => Self::P010,
            118 => Self::R8G8B8,
            4294967294 => Self::DoNotCare,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Invalid => 0,
            Self::R8G8B8A8 => 1,
            Self::R8G8B8X8 => 119,
            Self::B8G8R8A8 => 101,
            Self::B8G8R8X8 => 120,
            Self::I420 => 102,
            Self::M420 => 103,
            Self::Nv12 => 104,
            Self::Yuy2 => 105,
            Self::Mjpeg => 106,
            Self::Yv12 => 107,
            Self::B8G8R8 => 108,
            Self::R5G6B5 => 109,
            Self::R3G3B2 => 110,
            Self::R2G2B2X2 => 111,
            Self::L8 => 112,
            Self::R8 => 113,
            Self::R8G8 => 114,
            Self::A2R10G10B10 => 115,
            Self::A2B10G10R10 => 116,
            Self::P010 => 117,
            Self::R8G8B8 => 118,
            Self::DoNotCare => 4294967294,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// The upper 8 bits are a vendor code. The lower 56 bits are vendor-defined.
///
/// The defined `PixelFormatModifier` values are specific, complete, and valid
/// values (except for `INVALID` and `DO_NOT_CARE` which have their own
/// meanings).
///
/// Some other valid or potentially-valid `pixel_format_modifier` values are not
/// defined as a `PixelFormatModifier` value, typically because the value isn't
/// used in practice (or potentially is newly used but not yet defined in
/// `PixelFormatModifier`). It is permitted to specify such a value as a
/// `PixelFormatModifier` value in a `pixel_format_modifier` field, despite the
/// lack of corresponding defined `PixelFormatModifier` value. If such a value
/// is used outside test code, please consider adding it as a defined value in
/// `PixelFormatModifier`. All such values must conform to the upper 8 bits
/// vendor code (don't define/use values outside the/an appropriate vendor
/// code).
///
/// The separately-defined `FORMAT_MODIFIER_*` uint64 values are vendor-specific
/// bit field values, not complete valid values on their own. These uint64
/// values can be used to help create or interpret a `PixelFormatModifier` value
/// in terms of vendor-specific bitfields.
///
/// When the `pixel_format_modifier` is set to a supported value (excluding
/// `DO_NOT_CARE`, `INVALID`, `LINEAR`), the arrangement of pixel data otherwise
/// specified by the `pixel_format` field is "modified", typically to allow for
/// some combination of tiling, compression (typically lossless, typically for
/// memory bandwidth reduction not framebuffer size reduction), transaction
/// elimination, dirt tracking, but typically not modifying the bit depth of the
/// `pixel_format`. In some cases there's a per-image or per-tile header
/// involved, or similar. The `pixel_format` field often still needs to be set
/// to a valid supported value that works in combination with the
/// `pixel_format_modifier`, and that `pixel_format` value can also contribute
/// to the overall meaning of the `ImageFormat`. In other words, the "modifier"
/// part of the name is more accurate than "override" would be.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum PixelFormatModifier {
    DoNotCare,
    Invalid,
    Linear,
    IntelI915XTiled,
    IntelI915YTiled,
    IntelI915YfTiled,
    IntelI915YTiledCcs,
    IntelI915YfTiledCcs,
    ArmAfbc16X16,
    ArmAfbc32X8,
    ArmLinearTe,
    ArmAfbc16X16Te,
    ArmAfbc32X8Te,
    ArmAfbc16X16YuvTiledHeader,
    ArmAfbc16X16SplitBlockSparseYuv,
    ArmAfbc16X16SplitBlockSparseYuvTe,
    ArmAfbc16X16SplitBlockSparseYuvTiledHeader,
    ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader,
    GoogleGoldfishOptimal,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `PixelFormatModifier` member.
#[macro_export]
macro_rules! PixelFormatModifierUnknown {
    () => {
        _
    };
}

impl PixelFormatModifier {
    #[inline]
    pub fn from_primitive(prim: u64) -> Option<Self> {
        match prim {
            72057594037927934 => Some(Self::DoNotCare),
            72057594037927935 => Some(Self::Invalid),
            0 => Some(Self::Linear),
            72057594037927937 => Some(Self::IntelI915XTiled),
            72057594037927938 => Some(Self::IntelI915YTiled),
            72057594037927939 => Some(Self::IntelI915YfTiled),
            72057594054705154 => Some(Self::IntelI915YTiledCcs),
            72057594054705155 => Some(Self::IntelI915YfTiledCcs),
            576460752303423489 => Some(Self::ArmAfbc16X16),
            576460752303423490 => Some(Self::ArmAfbc32X8),
            576460752303427584 => Some(Self::ArmLinearTe),
            576460752303427585 => Some(Self::ArmAfbc16X16Te),
            576460752303427586 => Some(Self::ArmAfbc32X8Te),
            576460752303431697 => Some(Self::ArmAfbc16X16YuvTiledHeader),
            576460752303423601 => Some(Self::ArmAfbc16X16SplitBlockSparseYuv),
            576460752303427697 => Some(Self::ArmAfbc16X16SplitBlockSparseYuvTe),
            576460752303431793 => Some(Self::ArmAfbc16X16SplitBlockSparseYuvTiledHeader),
            576460752303435889 => Some(Self::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader),
            7421932185906577409 => Some(Self::GoogleGoldfishOptimal),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u64) -> Self {
        match prim {
            72057594037927934 => Self::DoNotCare,
            72057594037927935 => Self::Invalid,
            0 => Self::Linear,
            72057594037927937 => Self::IntelI915XTiled,
            72057594037927938 => Self::IntelI915YTiled,
            72057594037927939 => Self::IntelI915YfTiled,
            72057594054705154 => Self::IntelI915YTiledCcs,
            72057594054705155 => Self::IntelI915YfTiledCcs,
            576460752303423489 => Self::ArmAfbc16X16,
            576460752303423490 => Self::ArmAfbc32X8,
            576460752303427584 => Self::ArmLinearTe,
            576460752303427585 => Self::ArmAfbc16X16Te,
            576460752303427586 => Self::ArmAfbc32X8Te,
            576460752303431697 => Self::ArmAfbc16X16YuvTiledHeader,
            576460752303423601 => Self::ArmAfbc16X16SplitBlockSparseYuv,
            576460752303427697 => Self::ArmAfbc16X16SplitBlockSparseYuvTe,
            576460752303431793 => Self::ArmAfbc16X16SplitBlockSparseYuvTiledHeader,
            576460752303435889 => Self::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader,
            7421932185906577409 => Self::GoogleGoldfishOptimal,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffffffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u64 {
        match self {
            Self::DoNotCare => 72057594037927934,
            Self::Invalid => 72057594037927935,
            Self::Linear => 0,
            Self::IntelI915XTiled => 72057594037927937,
            Self::IntelI915YTiled => 72057594037927938,
            Self::IntelI915YfTiled => 72057594037927939,
            Self::IntelI915YTiledCcs => 72057594054705154,
            Self::IntelI915YfTiledCcs => 72057594054705155,
            Self::ArmAfbc16X16 => 576460752303423489,
            Self::ArmAfbc32X8 => 576460752303423490,
            Self::ArmLinearTe => 576460752303427584,
            Self::ArmAfbc16X16Te => 576460752303427585,
            Self::ArmAfbc32X8Te => 576460752303427586,
            Self::ArmAfbc16X16YuvTiledHeader => 576460752303431697,
            Self::ArmAfbc16X16SplitBlockSparseYuv => 576460752303423601,
            Self::ArmAfbc16X16SplitBlockSparseYuvTe => 576460752303427697,
            Self::ArmAfbc16X16SplitBlockSparseYuvTiledHeader => 576460752303431793,
            Self::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader => 576460752303435889,
            Self::GoogleGoldfishOptimal => 7421932185906577409,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// An integral, rectangular, axis-aligned region in a 2D cartesian
/// space, with unsigned location and distance fields.
///
/// This type does not specify units. Protocols that use this type should
/// specify the characteristics of the vector space, including orientation and
/// units.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct RectU {
    /// The location of the origin of the rectangle in the x-axis.
    pub x: u32,
    /// The location of the origin of the rectangle in the y-axis.
    pub y: u32,
    /// The distance along the x-axis.
    ///
    /// The region includes x values starting at `x` and increasing along the
    /// x-axis.
    pub width: u32,
    /// The distance along the y-axis.
    ///
    /// The region includes y values starting at `y` and increasing along the
    /// y-axis.
    pub height: u32,
}

impl fidl::Persistable for RectU {}

/// Describes the format of images.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ImageFormat {
    /// Describes the manner in which pixels are encoded.
    pub pixel_format: Option<PixelFormat>,
    /// Vendor-specific pixel format modifier. See format_modifier.fidl.
    pub pixel_format_modifier: Option<PixelFormatModifier>,
    /// Indicates the color space used to interpret pixel values.
    pub color_space: Option<ColorSpace>,
    /// The size of the image in pixels.
    ///
    /// See also `bytes_per_row` which is also necessary (along with `size`) to
    /// find where each pixel's data is within a buffer.
    ///
    /// Not all of the addressable pixel positions in the buffer are necessarily
    /// populated with valid pixel data. See `valid_size` for the
    /// potentially-smaller rectangle of valid pixels.
    ///
    /// The right and bottom of the image may have some valid pixels which are
    /// not to be displayed.  See `display_rect`.
    pub size: Option<fidl_fuchsia_math::SizeU>,
    /// Number of bytes per row. For multi-plane YUV formats, this is the number
    /// of bytes per row in the Y plane.
    ///
    /// When this field is not set, there is no padding at the end of each row
    /// of pixels. In other words, when not set, the stride is equal to the
    /// "stride bytes per width pixel" times the `size.width`.
    ///
    /// When set, the value in this field must be >= the "stride bytes per width
    /// pixel" times the `size.width`. If equal, there is no padding at
    /// the end of each row of pixels. If greater, the difference is how much
    /// padding is at the end of each row of pixels, in bytes.
    ///
    /// This is also known as the "stride", "line to line offset", "row to row
    /// offset", and other names.
    ///
    /// As a specific example, it's not uncommon (but also not always required)
    /// for BGR24 (3 bytes per pixel) to have some padding at the end of each
    /// row so that each row of pixels starts at a 4 byte aligned offset from
    /// the start of the image (the upper left pixel). That padding's size is
    /// not necessarily divisible by the size in bytes of a pixel ("stride bytes
    /// per width pixel"), so we indicate the padding using this field rather
    /// than trying to incorporate the padding as a larger "fake"
    /// `size.width`.
    pub bytes_per_row: Option<u32>,
    /// The rect within a frame that's for display. This is the location and
    /// size in pixels of the rectangle of pixels that should be displayed, when
    /// displaying the "whole image" in a UI display sense.
    ///
    /// The `x` + `width` must be <= `size.width`, and the `y` + `height` must
    /// be <= `size.height`.
    ///
    /// For output from a video decoder, pixels outside the display_rect are
    /// never to be displayed (outside of test programs), but must be preserved
    /// for correct decoder function.  The `display_rect` will always fall
    /// within the rect starting at (0, 0) and having `valid_size` size, when
    /// `valid_size` is set.  In other words, `display_rect` is a subset (not
    /// necessarily a proper subset) of `valid_size`, and `valid_size` is a
    /// subset (not necessarily a proper subset) of `size`.
    ///
    /// Downstream texture filtering operations should avoid letting any pixel
    /// outside of display_rect influence the visual appearance of any displayed
    /// pixel, to avoid the potential for the right or bottom edge leaking in
    /// arbitrary pixels defined by the decode process but not intended for
    /// display.
    ///
    /// Behavior when this field is not set is protocol-specific. In some
    /// protocols, fallback to `valid_size`, then to `size` may be implemented.
    /// In others, fallback directly to `size` may be implemented. In others,
    /// this field must be set or the channel will close.
    ///
    /// WARNING: fuchsia.sysmem.Images2 (V1) doesn't handle non-zero x, y, so
    /// any non-zero x, y here (V2) will prevent conversion to V1.  Due to the
    /// rarity of non-zero x, y in practice, even components that have moved to
    /// V2 may in some cases still assume both x and y are 0, until there's a
    /// practical reason to implment and test handling of non-zero x, y.  The
    /// symptom of sending non-zero x, y to a downstream render and/or display
    /// pipeline that assumes 0, 0 will be incorrect display, but not a crash,
    /// since assuming 0, 0 for x, y does not cause reading out of buffer
    /// bounds.
    pub display_rect: Option<fidl_fuchsia_math::RectU>,
    /// The size of a frame in terms of the number of pixels that have valid
    /// pixel data in terms of video decoding, but not in terms of which pixels
    /// are intended for display.
    ///
    /// To convert valid_size into a rect that's directly comparable to
    /// `display_rect`, one can make a rect with (`x`: 0, `y`: 0, `width`:
    /// `valid_size.width`, `height`: `valid_size.height`).
    ///
    /// In the case of a video decoder, `valid_size` can include some pixels
    /// outside `display_rect`. The extra pixels are not meant to be displayed,
    /// and may or may not contain any real image data. Typically anything that
    /// looks like real image data in these regions is only an artifact of video
    /// compression and the existence of the remainder of a macroblock which can
    /// be referenced by later frames despite not being within the displayed
    /// region, and not really any additional "real" pixels from the source. The
    /// pixel values in this region are defined by the codec decode process and
    /// must be retained for correct decoder operation. Typically the pixels
    /// inside valid_size but outside display_rect will be up to the size of a
    /// macroblock minus 1. The `valid_size` is can be useful for testing video
    /// decoders and for certain transcoding scenarios.
    pub valid_size: Option<fidl_fuchsia_math::SizeU>,
    /// Aspect ratio of a single pixel as the video is intended to be displayed.
    ///
    /// For YUV formats, this is the pixel aspect ratio (AKA sample aspect ratio
    /// aka SAR) for the luma (AKA Y) samples.
    ///
    /// Producers should ensure the width and height values are relatively prime
    /// by reducing the fraction (dividing both by GCF) if necessary.
    ///
    /// A consumer should interpret this field being un-set as an unknown pixel
    /// aspect ratio.  A default of 1:1 can be appropriate in some cases, but a
    /// consumer may determine the actual pixel aspect ratio by OOB means.
    pub pixel_aspect_ratio: Option<fidl_fuchsia_math::SizeU>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ImageFormat {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for ColorSpace {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ColorSpace {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ColorSpace {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorSpace {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for PixelFormat {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PixelFormat {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PixelFormat {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PixelFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for PixelFormatModifier {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u64>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u64>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PixelFormatModifier {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for PixelFormatModifier
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PixelFormatModifier {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for RectU {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RectU {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RectU, D> for &RectU {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RectU>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut RectU).write_unaligned((self as *const RectU).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u32, D>,
            T1: fidl::encoding::Encode<u32, D>,
            T2: fidl::encoding::Encode<u32, D>,
            T3: fidl::encoding::Encode<u32, D>,
        > fidl::encoding::Encode<RectU, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RectU>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 12, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RectU {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                x: fidl::new_empty!(u32, D),
                y: fidl::new_empty!(u32, D),
                width: fidl::new_empty!(u32, D),
                height: fidl::new_empty!(u32, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    impl ImageFormat {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.pixel_aspect_ratio {
                return 8;
            }
            if let Some(_) = self.valid_size {
                return 7;
            }
            if let Some(_) = self.display_rect {
                return 6;
            }
            if let Some(_) = self.bytes_per_row {
                return 5;
            }
            if let Some(_) = self.size {
                return 4;
            }
            if let Some(_) = self.color_space {
                return 3;
            }
            if let Some(_) = self.pixel_format_modifier {
                return 2;
            }
            if let Some(_) = self.pixel_format {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ImageFormat {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ImageFormat {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageFormat, D>
        for &ImageFormat
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormat>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<PixelFormat, D>(
                self.pixel_format
                    .as_ref()
                    .map(<PixelFormat as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<PixelFormatModifier, D>(
                self.pixel_format_modifier
                    .as_ref()
                    .map(<PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<ColorSpace, D>(
                self.color_space
                    .as_ref()
                    .map(<ColorSpace as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::SizeU, D>(
                self.size
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u32, D>(
                self.bytes_per_row.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (6 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::RectU, D>(
                self.display_rect
                    .as_ref()
                    .map(<fidl_fuchsia_math::RectU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (7 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::SizeU, D>(
                self.valid_size
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (8 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::SizeU, D>(
                self.pixel_aspect_ratio
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <PixelFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.pixel_format.get_or_insert_with(|| fidl::new_empty!(PixelFormat, D));
                fidl::decode!(PixelFormat, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <PixelFormatModifier as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .pixel_format_modifier
                    .get_or_insert_with(|| fidl::new_empty!(PixelFormatModifier, D));
                fidl::decode!(PixelFormatModifier, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <ColorSpace as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.color_space.get_or_insert_with(|| fidl::new_empty!(ColorSpace, D));
                fidl::decode!(ColorSpace, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.size.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.bytes_per_row.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 6 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_math::RectU as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .display_rect
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::RectU, D));
                fidl::decode!(
                    fidl_fuchsia_math::RectU,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 7 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .valid_size
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 8 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .pixel_aspect_ratio
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }
}