fidl_fuchsia_hardware_display_types/

fidl_fuchsia_hardware_display_types.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;

/// See [`fuchsia.hardware.display.types/ConfigStamp`].
pub type ConfigStampValue = u64;

/// Type of the internal value in [`fuchsia.hardware.display.types/DisplayId`].
pub type DisplayIdValue = u64;

/// Specifies how individual pixels are arranged in an image buffer.
///
/// The tiling format influences other image parameters, such as dimensions
/// and pixel format, that are supported by the display engines. Display engine
/// drivers currently express this knowledge by setting buffer constraints in
/// sysmem, and by rejecting invalid combinations.
///
/// Values other than [`IMAGE_TILING_TYPE_LINEAR`] and
/// [`IMAGE_TILING_TYPE_CAPTURE`] are an escape hatch. The driver and image
/// producer are responsible for agreeing on the meaning of the value, through
/// some mechanism outside the scope of this API.
pub type ImageTilingTypeIdValue = u32;

/// The tiling used by the display engine's capture feature.
///
/// This value is used as a signal that the image buffer will used by the
/// display engine to store displayed contents, and therefore is a slight abuse
/// of the "tiling" semantics.
///
/// Like every other tiling value, this introduces constraints on image
/// parameters such as dimensions and pixel format.
pub const IMAGE_TILING_TYPE_CAPTURE: u32 = 10;

/// Equivalent to Vulkan's linear tiling.
///
/// Pixels are arranged in the image buffer in row-major order. Each row may
/// have some padding bytes.
///
/// Default for [`ImageTilingTypeIdValue`].
pub const IMAGE_TILING_TYPE_LINEAR: u32 = 0;

pub const INVALID_CONFIG_STAMP_VALUE: u64 = 0;

/// Invalid id for displays, images, and events.
pub const INVALID_DISP_ID: u64 = 0;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum AlphaMode {
    /// Alpha is disabled for the plane (default).
    Disable = 0,
    /// Plane alpha is premultiplied.
    Premultiplied = 1,
    /// Hardware should multiply the alpha and color channels when blending.
    HwMultiply = 2,
}

impl AlphaMode {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::Disable),
            1 => Some(Self::Premultiplied),
            2 => Some(Self::HwMultiply),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum ClientCompositionOpcode {
    /// The client should configure the layer to use a source image.
    ClientUseImage = 0,
    /// The client should compose all layers with CLIENT_MERGE_BASE and CLIENT_MERGE_SRC
    /// into a new, single primary layer at the CLIENT_MERGE_BASE layer's z-order. The
    /// driver must accept a fullscreen layer with the default pixel format, but may
    /// accept other layer parameters.
    ///
    /// CLIENT_MERGE_BASE will only be set on one layer per display.
    ClientMergeBase = 1,
    /// See CLIENT_MERGE_BASE.
    ClientMergeSrc = 2,
    /// The client should provide a new image produced by scaling the source image
    /// such that the dimensions of the new image's src_frame and dest_frame are
    /// equal to the dimensions of the current image's dest_frame.
    ClientFrameScale = 3,
    /// The client should provide a new image produced by clipping the source image
    /// to the region specified by src_frame.
    ClientSrcFrame = 4,
    /// The client should provide a new image produced by applying the desired
    /// transformation, so that TRANSFORM_IDENTITY can be specified.
    ClientTransform = 5,
    /// The client should apply the color conversion itself.
    ClientColorConversion = 6,
    /// The client should apply the alpha itself.
    ClientAlpha = 7,
}

impl ClientCompositionOpcode {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::ClientUseImage),
            1 => Some(Self::ClientMergeBase),
            2 => Some(Self::ClientMergeSrc),
            3 => Some(Self::ClientFrameScale),
            4 => Some(Self::ClientSrcFrame),
            5 => Some(Self::ClientTransform),
            6 => Some(Self::ClientColorConversion),
            7 => Some(Self::ClientAlpha),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// The result of checking a draft display config.
///
/// Values are produced by [`fuchsia.hardware.display/Coordinator.CheckConfig`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ConfigResult {
    /// The config is compatible with the current hardware.
    Ok = 0,
    /// The config is not compatible with any hardware.
    InvalidConfig = 1,
    /// The config layer assignment is not supported by the current hardware.
    UnsupportedConfig = 2,
    /// The config uses more than the number of connected displays.
    TooManyDisplays = 3,
    /// The config display modes are not supported by the current hardware.
    ///
    /// The client should try a different set of displays or display modes.
    UnsupportedDisplayModes = 4,
}

impl ConfigResult {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Ok),
            1 => Some(Self::InvalidConfig),
            2 => Some(Self::UnsupportedConfig),
            3 => Some(Self::TooManyDisplays),
            4 => Some(Self::UnsupportedDisplayModes),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Transformations that can be applied by display hardware to input images.
///
/// The coordinate system transformations listed here can be implemented in
/// hardware by display engines, because they have straightforward
/// implementations for raster images.
///
/// Support for input image transformations (every member except for `IDENTITY`)
/// varies across display engines. This is because each transformation requires
/// non-trivial hardware modifications that have area (cost) and power
/// implications.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum CoordinateTransformation {
    /// Image pixels are passed through without any change.
    ///
    /// This is the only value guaranteed to be supported by all display engine
    /// drivers.
    Identity = 0,
    /// Image pixels are reflected across a line meeting the image's center, parallel to the X axis.
    ///
    /// This enum member's numeric value has a single bit set to 1. Any
    /// transformation whose value has this bit set involves an X reflection.
    ///
    /// This transformation is also called an "X flip".
    ///
    /// Example:
    /// |a b c d|      |i j k l|
    /// |e f g h|  ->  |e f g h|
    /// |i j k l|      |a b c d|
    ReflectX = 1,
    /// Image pixels are reflected across a line meeting the image's center, parallel to the Y axis.
    ///
    /// This enum member's numeric value has a single bit set to 1. Any
    /// transformation whose value has this bit set involves an Y reflection.
    ///
    /// This transformation is also called an "Y flip".
    ///
    /// Example:
    /// |a b c d|      |d c b a|
    /// |e f g h|  ->  |h g f e|
    /// |i j k l|      |l k j i|
    ReflectY = 2,
    /// Image pixels are rotated around the image's center counter-clockwise by 180 degrees.
    ///
    /// This is equivalent to applying the `REFLECT_X` and `REFLECT_Y`
    /// transforms. `REFLECT_X` and `REFLECT_Y` are commutative, so their
    /// ordering doesn't matter.
    ///
    /// Example:
    /// |a b c d|      |l k j i|
    /// |e f g h|  ->  |h g f e|
    /// |i j k l|      |d c b a|
    RotateCcw180 = 3,
    /// Image pixels are rotated around the image's center counter-clockwise by 90 degrees.
    ///
    /// The image produced by this transformation has different dimensions from
    /// the input image.
    ///
    /// This enum member's numeric value has a single bit set to 1. Any
    /// transformation whose value has this bit set involves a 90-degree
    /// counter-clockwise rotation.
    ///
    /// Example:
    /// |a b c d|      |d h l|
    /// |e f g h|  ->  |c g k|
    /// |i j k l|      |b f j|
    ///                |a e i|
    RotateCcw90 = 4,
    /// Image pixels are transformed using `ROTATE_CCW_90`, followed by `REFLECT_X`.
    ///
    /// The image produced by this transformation has different dimensions from
    /// the input image.
    ///
    /// Example:
    /// |a b c d|      |a e i|
    /// |e f g h|  ->  |b f k|
    /// |i j k l|      |c g k|
    ///                |d h l|
    RotateCcw90ReflectX = 5,
    /// Image pixels are transformed using `ROTATE_CCW_90`, followed by `REFLECT_Y`.
    ///
    /// The image produced by this transformation has different dimensions from
    /// the input image.
    ///
    /// Example:
    /// |a b c d|      |l h d|
    /// |e f g h|  ->  |k g c|
    /// |i j k l|      |j f b|
    ///                |i e a|
    RotateCcw90ReflectY = 6,
    /// Image pixels are rotated around the image's center counter-clockwise by 270 degrees.
    ///
    /// The image produced by this transformation has different dimensions from
    /// the input image.
    ///
    /// This is equivalent to applying the `ROTATE_CCW_90` transform, followed
    /// by `REFLECT_X` and `REFLECT_Y`. `REFLECT_X` and `REFLECT_Y` are
    /// commutative, so their ordering doesn't matter.
    ///
    /// Example:
    /// |a b c d|      |i e a|
    /// |e f g h|  ->  |j f b|
    /// |i j k l|      |k g c|
    ///                |l h d|
    RotateCcw270 = 7,
}

impl CoordinateTransformation {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::Identity),
            1 => Some(Self::ReflectX),
            2 => Some(Self::ReflectY),
            3 => Some(Self::RotateCcw180),
            4 => Some(Self::RotateCcw90),
            5 => Some(Self::RotateCcw90ReflectX),
            6 => Some(Self::RotateCcw90ReflectY),
            7 => Some(Self::RotateCcw270),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// A color constant.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Color {
    /// The format of pixel data stored in `bytes`.
    ///
    /// The format must use a single plane. The encoding of one pixel
    /// must fit within the `bytes` array.
    pub format: fidl_fuchsia_images2::PixelFormat,
    /// The constant color, expressed as one pixel encoded using `format`.
    ///
    /// The pixel is encoded using little-endian byte ordering and zero padding.
    /// In other words, the bytes obtained by encoding the pixel using `format`
    /// are stored starting at the first byte in the array. If the pixel
    /// requires fewer bytes per pixel than the array size, any unused bytes
    /// (towards the end of the array) must be set to 0 (zero).
    pub bytes: [u8; 8],
}

impl fidl::Persistable for Color {}

/// Identifies an accepted display config.
///
/// This is a type-safe wrapper for a
/// [`fuchsia.hardware.display.types/ConfigStampValue`], which is a raw numeric
/// value.
///
/// Each successful call to [`fuchsia.hardware.display/Coordinator.ApplyConfig`]
/// generates a valid value. Values are reported in
/// [`fuchsia.hardware.display/Coordinator.Vsync`] events.
///
/// Generated values are strictly increasing (unique, strictly monotonic) within
/// the lifetime of a [`fuchsia.display/Coordinator`] connection.
///
/// [`fuchsia.hardware.display.types/INVALID_CONFIG_STAMP_VALUE`] represents an
/// invalid value.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ConfigStamp {
    pub value: u64,
}

impl fidl::Persistable for ConfigStamp {}

/// Unique identifier for a display device attached to the system.
///
/// [`fuchsia.hardware.display.types/INVALID_DISP_ID`] represents an invalid
/// value.
///
/// Values are unique within a [`fuchsia.hardware.display/Controller`]
/// connection. An external display will be associated with different display ID
/// values if it is disconnected and reconnected.
///
/// A display device may be identified by different values across boot cycles or
/// across different Controller connections. Software that needs to identify
/// displays (for example, to honor display-specific preferences) should use
/// [`fuchsia.hardware.display/Info`] identifiers, not display IDs.
///
/// This type is not related to the VESA DisplayID standard.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DisplayId {
    pub value: u64,
}

impl fidl::Persistable for DisplayId {}

/// The intended usage for a sysmem BufferCollection holding image buffers.
///
/// Each buffer in the collection will store a single image, which is intended
/// to be used as described below.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImageBufferUsage {
    /// Specifies how individual pixels are arranged in an image buffer.
    ///
    /// See [`fuchsia.hardware.display.types/ImageTilingTypeIdValue`].
    pub tiling_type: u32,
}

impl fidl::Persistable for ImageBufferUsage {}

/// Describes how an image is stored in a buffer of a sysmem BufferCollection.
///
/// The buffer is dedicated to storing a single image. The properties below are
/// needed for decoding the image from the buffer.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImageMetadata {
    /// The width and height of the image in pixels.
    pub width: u32,
    pub height: u32,
    /// Specifies how individual pixels are arranged in an image buffer.
    ///
    /// See [`fuchsia.hardware.display.types/ImageTilingTypeIdValue`].
    pub tiling_type: u32,
}

impl fidl::Persistable for ImageMetadata {}

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for AlphaMode {
        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 AlphaMode {
        #[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 AlphaMode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Disable
        }

        #[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::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ClientCompositionOpcode {
        type Owned = Self;

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for ClientCompositionOpcode {
        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 ClientCompositionOpcode
    {
        #[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 ClientCompositionOpcode
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::ClientUseImage
        }

        #[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::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ConfigResult {
        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 {
            true
        }

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

    impl fidl::encoding::ValueTypeMarker for ConfigResult {
        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 ConfigResult {
        #[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 ConfigResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Ok
        }

        #[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(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for CoordinateTransformation {
        type Owned = Self;

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for CoordinateTransformation {
        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 CoordinateTransformation
    {
        #[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 CoordinateTransformation
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Identity
        }

        #[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::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Color, D> for &Color {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Color>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Color, D>::encode(
                (
                    <fidl_fuchsia_images2::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.format,
                    ),
                    <fidl::encoding::Array<u8, 8> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.bytes,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_images2::PixelFormat, D>,
            T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 8>, D>,
        > fidl::encoding::Encode<Color, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Color>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Color {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                format: fidl::new_empty!(fidl_fuchsia_images2::PixelFormat, D),
                bytes: fidl::new_empty!(fidl::encoding::Array<u8, 8>, 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);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_images2::PixelFormat,
                D,
                &mut self.format,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Array<u8, 8>, D, &mut self.bytes, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[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<ConfigStamp, D>
        for &ConfigStamp
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConfigStamp>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ConfigStamp).write_unaligned((self as *const ConfigStamp).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<u64, D>>
        fidl::encoding::Encode<ConfigStamp, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConfigStamp>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigStamp {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, 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, 8);
            }
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[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<DisplayId, D>
        for &DisplayId
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DisplayId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DisplayId).write_unaligned((self as *const DisplayId).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<u64, D>>
        fidl::encoding::Encode<DisplayId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DisplayId>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DisplayId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, 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, 8);
            }
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[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<ImageBufferUsage, D>
        for &ImageBufferUsage
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageBufferUsage>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ImageBufferUsage)
                    .write_unaligned((self as *const ImageBufferUsage).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>>
        fidl::encoding::Encode<ImageBufferUsage, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageBufferUsage>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageBufferUsage {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { tiling_type: 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, 4);
            }
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
        #[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<ImageMetadata, D>
        for &ImageMetadata
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageMetadata>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ImageMetadata)
                    .write_unaligned((self as *const ImageMetadata).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>,
        > fidl::encoding::Encode<ImageMetadata, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageMetadata>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageMetadata {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                width: fidl::new_empty!(u32, D),
                height: fidl::new_empty!(u32, D),
                tiling_type: 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, 12);
            }
            Ok(())
        }
    }
}