fuchsia_image_format/

image_format.rs

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use anyhow::{Error, anyhow, format_err};
use fidl_fuchsia_images2 as fimages2;
use fidl_fuchsia_math::{RectU, SizeU};
use fidl_fuchsia_sysmem as fsysmem;
use fidl_fuchsia_sysmem2 as fsysmem2;

use super::linux_drm::DRM_FORMAT_MOD_LINEAR;
use super::round_up_to_increment;

/// The default image format constraints for allocating buffers.
pub const IMAGE_FORMAT_CONSTRAINTS_DEFAULT: fsysmem::ImageFormatConstraints =
    fsysmem::ImageFormatConstraints {
        pixel_format: fsysmem::PixelFormat {
            type_: fsysmem::PixelFormatType::Nv12,
            has_format_modifier: false,
            format_modifier: fsysmem::FormatModifier { value: 0 },
        },
        color_spaces_count: 0,
        color_space: [fsysmem::ColorSpace { type_: fsysmem::ColorSpaceType::Invalid }; 32],
        min_coded_width: 0,
        max_coded_width: 0,
        min_coded_height: 0,
        max_coded_height: 0,
        min_bytes_per_row: 0,
        max_bytes_per_row: 0,
        max_coded_width_times_coded_height: 0,
        layers: 0,
        coded_width_divisor: 0,
        coded_height_divisor: 0,
        bytes_per_row_divisor: 0,
        start_offset_divisor: 0,
        display_width_divisor: 0,
        display_height_divisor: 0,
        required_min_coded_width: 0,
        required_max_coded_width: 0,
        required_min_coded_height: 0,
        required_max_coded_height: 0,
        required_min_bytes_per_row: 0,
        required_max_bytes_per_row: 0,
    };

/// The default buffers usage for allocating buffers.
pub const BUFFER_USAGE_DEFAULT: fsysmem::BufferUsage =
    fsysmem::BufferUsage { none: 0, cpu: 0, vulkan: 0, display: 0, video: 0 };

/// The default buffer memory constraints for allocating buffers.
pub const BUFFER_MEMORY_CONSTRAINTS_DEFAULT: fsysmem::BufferMemoryConstraints =
    fsysmem::BufferMemoryConstraints {
        min_size_bytes: 0,
        max_size_bytes: u32::MAX,
        physically_contiguous_required: false,
        secure_required: false,
        ram_domain_supported: false,
        cpu_domain_supported: true,
        inaccessible_domain_supported: false,
        heap_permitted_count: 0,
        heap_permitted: [fsysmem::HeapType::SystemRam; 32],
    };

/// The default buffer collection constraints for allocating buffers.
pub const BUFFER_COLLECTION_CONSTRAINTS_DEFAULT: fsysmem::BufferCollectionConstraints =
    fsysmem::BufferCollectionConstraints {
        usage: BUFFER_USAGE_DEFAULT,
        min_buffer_count_for_camping: 0,
        min_buffer_count_for_dedicated_slack: 0,
        min_buffer_count_for_shared_slack: 0,
        min_buffer_count: 0,
        max_buffer_count: 0,
        has_buffer_memory_constraints: false,
        buffer_memory_constraints: BUFFER_MEMORY_CONSTRAINTS_DEFAULT,
        image_format_constraints_count: 0,
        image_format_constraints: [IMAGE_FORMAT_CONSTRAINTS_DEFAULT; 32],
    };

const PVRIC_TILES_PLANE: u32 = 0;
const PVRIC_HEADER_PLANE: u32 = 3;
const PVRIC_HEADER_ALIGNMENT: u32 = 256;

fn is_pvric_pixel_format_supported(pixel_format: fimages2::PixelFormat) -> bool {
    matches!(
        pixel_format,
        fimages2::PixelFormat::R8G8B8A8
            | fimages2::PixelFormat::R8G8B8X8
            | fimages2::PixelFormat::B8G8R8A8
            | fimages2::PixelFormat::B8G8R8X8
            | fimages2::PixelFormat::A2R10G10B10
            | fimages2::PixelFormat::A2B10G10R10
            | fimages2::PixelFormat::R5G6B5
    )
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PvricTilingData {
    pub tile_rows: u32,
    pub bytes_per_row_per_tile: u32,
}

pub fn pvric_tiling_data(modifier: fimages2::PixelFormatModifier) -> Option<PvricTilingData> {
    match modifier {
        fimages2::PixelFormatModifier::PvrFbcdc8X8V14 => {
            Some(PvricTilingData { tile_rows: 8, bytes_per_row_per_tile: 32 })
        }
        fimages2::PixelFormatModifier::PvrFbcdc16X4V14 => {
            Some(PvricTilingData { tile_rows: 4, bytes_per_row_per_tile: 64 })
        }
        _ => None,
    }
}

/// Returns the number of bytes per row for a given plane.
///
/// Returns an error if no such number of bytes can be found, either because a number can't be
/// generated from `image_format` or because the `plane` is unsupported.
pub fn get_plane_row_bytes_2(
    image_format: &fimages2::ImageFormat,
    plane: u32,
) -> Result<u32, Error> {
    let bytes_per_row = *image_format
        .bytes_per_row
        .as_ref()
        .ok_or_else(|| anyhow!("ImageFormat.bytes_per_row missing - tiled format?"))?;

    // TODO(https://fxbug.dev/576739649): PVRIC is currently handled as a
    // special case. Generalize.
    if let Some(modifier) = image_format.pixel_format_modifier {
        if let Some(tiling) = pvric_tiling_data(modifier) {
            let pixel_format = *image_format
                .pixel_format
                .as_ref()
                .ok_or_else(|| anyhow!("ImageFormat.pixel_format missing"))?;
            if !is_pvric_pixel_format_supported(pixel_format) {
                return Err(anyhow!("Invalid pixel format for PVRIC modifier."));
            }
            let width_in_tiles = bytes_per_row.div_ceil(tiling.bytes_per_row_per_tile);
            return match plane {
                PVRIC_TILES_PLANE => width_in_tiles
                    .checked_mul(tiling.bytes_per_row_per_tile)
                    .ok_or_else(|| anyhow!("Overflow calculating plane 0 row bytes.")),
                PVRIC_HEADER_PLANE => Ok(width_in_tiles),
                _ => Err(anyhow!("Invalid plane.")),
            };
        }
    }
    match plane {
        0 => Ok(bytes_per_row),
        1 => {
            let pixel_format = image_format.pixel_format.as_ref().expect("pixel_format");
            match pixel_format {
                fimages2::PixelFormat::Nv12 => Ok(bytes_per_row),
                fimages2::PixelFormat::I420 | fimages2::PixelFormat::Yv12 => Ok(bytes_per_row / 2),
                _ => Err(anyhow!("Invalid pixel format for plane 1.")),
            }
        }
        2 => {
            let pixel_format = image_format.pixel_format.as_ref().expect("pixel_format");
            match pixel_format {
                fimages2::PixelFormat::I420 | fimages2::PixelFormat::Yv12 => Ok(bytes_per_row / 2),
                _ => Err(anyhow!("Invalid pixel format for plane 2.")),
            }
        }
        _ => Err(anyhow!("Invalid plane.")),
    }
}

/// Returns the number of bytes per row for a given plane.
///
/// Returns an error if no such number of bytes can be found, either because a number can't be
/// generated from `image_format` or because the `plane` is unsupported.
pub fn get_plane_row_bytes(image_format: &fsysmem::ImageFormat2, plane: u32) -> Result<u32, Error> {
    match plane {
        0 => Ok(image_format.bytes_per_row),
        1 => match image_format.pixel_format.type_ {
            fsysmem::PixelFormatType::Nv12 => Ok(image_format.bytes_per_row),
            fsysmem::PixelFormatType::I420 | fsysmem::PixelFormatType::Yv12 => {
                Ok(image_format.bytes_per_row / 2)
            }
            _ => Err(anyhow!("Invalid pixel format for plane 1.")),
        },
        2 => match image_format.pixel_format.type_ {
            fsysmem::PixelFormatType::I420 | fsysmem::PixelFormatType::Yv12 => {
                Ok(image_format.bytes_per_row / 2)
            }
            _ => Err(anyhow!("Invalid pixel format for plane 2.")),
        },
        _ => Err(anyhow!("Invalid plane.")),
    }
}

/// Returns the byte offset for the given plane.
///
/// Returns an error if the `plane` is unsupported or a valid offset can't be generated from
/// `image_format`.
pub fn image_format_plane_byte_offset_2(
    image_format: &fimages2::ImageFormat,
    plane: u32,
) -> Result<u32, Error> {
    // TODO(https://fxbug.dev/576739649): PVRIC is currently handled as a
    // special case. Generalize.
    if let Some(modifier) = image_format.pixel_format_modifier {
        if let Some(tiling) = pvric_tiling_data(modifier) {
            let pixel_format = *image_format
                .pixel_format
                .as_ref()
                .ok_or_else(|| anyhow!("ImageFormat.pixel_format missing"))?;
            if !is_pvric_pixel_format_supported(pixel_format) {
                return Err(anyhow!("Invalid pixel format for PVRIC modifier."));
            }
            let bytes_per_row = *image_format
                .bytes_per_row
                .as_ref()
                .ok_or_else(|| anyhow!("ImageFormat.bytes_per_row missing"))?;
            let size =
                image_format.size.as_ref().ok_or_else(|| anyhow!("ImageFormat.size missing"))?;
            let width_in_tiles = bytes_per_row.div_ceil(tiling.bytes_per_row_per_tile);
            let height_in_tiles = size.height.div_ceil(tiling.tile_rows);
            let num_tiles = width_in_tiles
                .checked_mul(height_in_tiles)
                .ok_or_else(|| anyhow!("Overflow calculating num_tiles."))?;
            let header_size = num_tiles
                .checked_next_multiple_of(PVRIC_HEADER_ALIGNMENT)
                .ok_or_else(|| anyhow!("Overflow calculating header_size."))?;
            return match plane {
                PVRIC_TILES_PLANE => Ok(header_size),
                PVRIC_HEADER_PLANE => Ok(0),
                _ => Err(anyhow!("Invalid plane.")),
            };
        }
    }
    match plane {
        0 => Ok(0),
        1 => match image_format.pixel_format.as_ref().expect("pixel_format") {
            fimages2::PixelFormat::Nv12
            | fimages2::PixelFormat::I420
            | fimages2::PixelFormat::Yv12 => Ok(image_format.size.as_ref().expect("size").height
                * image_format.bytes_per_row.as_ref().expect("bytes_per_row")),
            _ => Err(anyhow!("Invalid pixelformat for plane 1.")),
        },
        2 => match image_format.pixel_format.as_ref().expect("pixel_format") {
            fimages2::PixelFormat::I420 | fimages2::PixelFormat::Yv12 => {
                let size = image_format.size.as_ref().expect("size");
                let bytes_per_row = image_format.bytes_per_row.as_ref().expect("bytes_per_row");
                Ok(size.height * bytes_per_row + size.height / 2 * bytes_per_row / 2)
            }
            _ => Err(anyhow!("Invalid pixelformat for plane 2.")),
        },
        _ => Err(anyhow!("Invalid plane.")),
    }
}

/// Returns the byte offset for the given plane.
///
/// Returns an error if the `plane` is unsupported or a valid offset can't be generated from
/// `image_format`.
pub fn image_format_plane_byte_offset(
    image_format: &fsysmem::ImageFormat2,
    plane: u32,
) -> Result<u32, Error> {
    match plane {
        0 => Ok(0),
        1 => match image_format.pixel_format.type_ {
            fsysmem::PixelFormatType::Nv12
            | fsysmem::PixelFormatType::I420
            | fsysmem::PixelFormatType::Yv12 => {
                Ok(image_format.coded_height * image_format.bytes_per_row)
            }
            _ => Err(anyhow!("Invalid pixelformat for plane 1.")),
        },
        2 => match image_format.pixel_format.type_ {
            fsysmem::PixelFormatType::I420 | fsysmem::PixelFormatType::Yv12 => {
                Ok(image_format.coded_height * image_format.bytes_per_row
                    + image_format.coded_height / 2 * image_format.bytes_per_row / 2)
            }
            _ => Err(anyhow!("Invalid pixelformat for plane 2.")),
        },
        _ => Err(anyhow!("Invalid plane.")),
    }
}

/// Returns the linear size for the given `type_`.
///
/// Returns an error if `type_` is unsupported.
pub fn linear_size(
    coded_height: u32,
    bytes_per_row: u32,
    type_: &fsysmem::PixelFormatType,
) -> Result<u32, Error> {
    match type_ {
        fsysmem::PixelFormatType::R8G8B8A8
        | fsysmem::PixelFormatType::Bgra32
        | fsysmem::PixelFormatType::Bgr24
        | fsysmem::PixelFormatType::Rgb565
        | fsysmem::PixelFormatType::Rgb332
        | fsysmem::PixelFormatType::Rgb2220
        | fsysmem::PixelFormatType::L8
        | fsysmem::PixelFormatType::R8
        | fsysmem::PixelFormatType::R8G8
        | fsysmem::PixelFormatType::A2B10G10R10
        | fsysmem::PixelFormatType::A2R10G10B10 => Ok(coded_height * bytes_per_row),
        fsysmem::PixelFormatType::I420 => Ok(coded_height * bytes_per_row * 3 / 2),
        fsysmem::PixelFormatType::M420 => Ok(coded_height * bytes_per_row * 3 / 2),
        fsysmem::PixelFormatType::Nv12 => Ok(coded_height * bytes_per_row * 3 / 2),
        fsysmem::PixelFormatType::Yuy2 => Ok(coded_height * bytes_per_row),
        fsysmem::PixelFormatType::Yv12 => Ok(coded_height * bytes_per_row * 3 / 2),
        _ => Err(anyhow!("Invalid pixel format.")),
    }
}

/// Converts a `fsysmem::ImageFormatConstraints` to an `fimages2::ImageFormat`.
pub fn constraints_to_image_format(
    constraints: &fsysmem2::ImageFormatConstraints,
    coded_width: u32,
    coded_height: u32,
) -> Result<fimages2::ImageFormat, Error> {
    if let Some(min_size) = &constraints.min_size {
        if coded_width < min_size.width {
            return Err(anyhow!("Coded width < min_size.width"));
        }
        if coded_height < min_size.height {
            return Err(anyhow!("Coded height < min_size.height"));
        }
    }
    if let Some(max_size) = &constraints.max_size {
        if coded_width > max_size.width {
            return Err(anyhow!("Coded width > max_size.width"));
        }
        if coded_height > max_size.height {
            return Err(anyhow!("Coded height > max_size.height"));
        }
    }

    let pixel_format_and_modifier = first_pixel_format_and_modifier_from_constraints(constraints)?;

    let color_space = if constraints.color_spaces.is_some()
        && constraints.color_spaces.as_ref().unwrap().len() > 0
    {
        Some(constraints.color_spaces.as_ref().unwrap()[0])
    } else {
        None
    };

    let format = fimages2::ImageFormat {
        pixel_format: Some(pixel_format_and_modifier.pixel_format),
        pixel_format_modifier: Some(pixel_format_and_modifier.pixel_format_modifier),
        size: Some(SizeU { width: coded_width, height: coded_height }),
        bytes_per_row: image_format_minimum_row_bytes_2(constraints, coded_width).ok(),
        color_space,
        ..Default::default()
    };

    Ok(format)
}

/// Converts a `fsysmem::ImageFormatConstraints` to an `fsysmem::ImageFormat2`.
pub fn constraints_to_format(
    constraints: &fsysmem::ImageFormatConstraints,
    coded_width: u32,
    coded_height: u32,
) -> Result<fsysmem::ImageFormat2, Error> {
    if coded_width < constraints.min_coded_width
        || (constraints.max_coded_width > 0 && coded_width > constraints.max_coded_width)
    {
        return Err(anyhow!("Coded width not within constraint bounds."));
    }
    if coded_height < constraints.min_coded_height
        || (constraints.max_coded_height > 0 && coded_height > constraints.max_coded_height)
    {
        return Err(anyhow!("Coded height not within constraint bounds."));
    }

    let format = fsysmem::ImageFormat2 {
        pixel_format: constraints.pixel_format,
        coded_width,
        coded_height,
        bytes_per_row: image_format_minimum_row_bytes(constraints, coded_width).unwrap_or(0),
        display_width: coded_width,
        display_height: coded_height,
        layers: 0,
        color_space: if constraints.color_spaces_count > 0 {
            constraints.color_space[0]
        } else {
            fsysmem::ColorSpace { type_: fsysmem::ColorSpaceType::Invalid }
        },
        has_pixel_aspect_ratio: false,
        pixel_aspect_ratio_width: 0,
        pixel_aspect_ratio_height: 0,
    };

    Ok(format)
}

fn first_pixel_format_and_modifier_from_constraints(
    constraints: &fsysmem2::ImageFormatConstraints,
) -> Result<fsysmem2::PixelFormatAndModifier, Error> {
    Ok(if let Some(pixel_format) = constraints.pixel_format {
        fsysmem2::PixelFormatAndModifier {
            pixel_format,
            pixel_format_modifier: *constraints
                .pixel_format_modifier
                .as_ref()
                .unwrap_or(&fimages2::PixelFormatModifier::Linear),
        }
    } else {
        constraints
            .pixel_format_and_modifiers
            .as_ref()
            .ok_or_else(|| format_err!("missing pixel_format"))?
            .get(0)
            .ok_or_else(|| format_err!("missing pixel_format"))?
            .clone()
    })
}

/// Returns the minimum row bytes for the given constraints and width.
///
/// Returns an error if the width is invalid given the constraints, or the constraint pixel format
/// modifier is invalid.
pub fn image_format_minimum_row_bytes_2(
    constraints: &fsysmem2::ImageFormatConstraints,
    width: u32,
) -> Result<u32, Error> {
    // TODO(https://fxbug.dev/576739649): PVRIC is currently handled as a
    // special case. Generalize.
    let pvric_tiling = match constraints.pixel_format_modifier {
        None | Some(fimages2::PixelFormatModifier::Linear) => None,
        Some(modifier) => match pvric_tiling_data(modifier) {
            Some(tiling) => Some(tiling),
            None => return Err(anyhow!("Non-linear format modifier.")),
        },
    };
    if pvric_tiling.is_some() {
        let pixel_format =
            *constraints.pixel_format.as_ref().ok_or_else(|| anyhow!("missing pixel_format"))?;
        if !is_pvric_pixel_format_supported(pixel_format) {
            return Err(anyhow!("Invalid pixel format for PVRIC modifier."));
        }
    }
    if let Some(min_size) = constraints.min_size {
        if width < min_size.width {
            return Err(anyhow!("width < min_size.width"));
        }
    }
    if let Some(max_size) = constraints.max_size {
        if width > max_size.width {
            return Err(anyhow!("width > max_size.width"));
        }
    }

    let constraints_min_bytes_per_row = constraints.min_bytes_per_row.unwrap_or(0);

    let maybe_stride_bytes_per_width_pixel = image_format_stride_bytes_per_width_pixel_2(
        *constraints.pixel_format.as_ref().expect("pixel_format"),
    )
    .ok();

    let mut bytes_per_row_divisor = constraints.bytes_per_row_divisor.unwrap_or(1);
    if *constraints.require_bytes_per_row_at_pixel_boundary.as_ref().unwrap_or(&false) {
        let stride_bytes_per_width_pixel = *maybe_stride_bytes_per_width_pixel.as_ref().ok_or_else(|| format_err!("stride_bytes_per_width_pixel required when require_bytes_per_row_at_pixel_boundary true"))?;
        bytes_per_row_divisor =
            num_integer::lcm(bytes_per_row_divisor, stride_bytes_per_width_pixel);
    }
    if let Some(tiling) = pvric_tiling {
        bytes_per_row_divisor =
            num_integer::lcm(bytes_per_row_divisor, tiling.bytes_per_row_per_tile);
    }
    let bytes_per_row_divisor = bytes_per_row_divisor;

    round_up_to_increment(
        std::cmp::max(
            maybe_stride_bytes_per_width_pixel.unwrap_or(0) * width,
            constraints_min_bytes_per_row,
        ) as usize,
        bytes_per_row_divisor as usize,
    )
    .map(|bytes| bytes as u32)
}

/// Returns the minimum row bytes for the given constraints and width.
///
/// Returns an error if the width is invalid given the constraints, or the constraint pixel format
/// modifier is invalid.
pub fn image_format_minimum_row_bytes(
    constraints: &fsysmem::ImageFormatConstraints,
    width: u32,
) -> Result<u32, Error> {
    if constraints.pixel_format.format_modifier.value != DRM_FORMAT_MOD_LINEAR {
        return Err(anyhow!("Non-linear format modifier."));
    }
    if width < constraints.min_coded_width
        || (constraints.max_coded_width > 0 && width > constraints.max_coded_width)
    {
        return Err(anyhow!("Width outside of constraints."));
    }

    let constraints_min_bytes_per_row = constraints.min_bytes_per_row;
    let constraints_bytes_per_row_divisor = constraints.bytes_per_row_divisor;

    round_up_to_increment(
        std::cmp::max(
            image_format_stride_bytes_per_width_pixel(&constraints.pixel_format) * width,
            constraints_min_bytes_per_row,
        ) as usize,
        constraints_bytes_per_row_divisor as usize,
    )
    .map(|bytes| bytes as u32)
}

pub fn image_format_stride_bytes_per_width_pixel_2(
    pixel_format: fimages2::PixelFormat,
) -> Result<u32, Error> {
    match pixel_format {
        fimages2::PixelFormat::R8G8B8A8 => Ok(4),
        fimages2::PixelFormat::R8G8B8X8 => Ok(4),
        fimages2::PixelFormat::B8G8R8A8 => Ok(4),
        fimages2::PixelFormat::B8G8R8X8 => Ok(4),
        fimages2::PixelFormat::B8G8R8 => Ok(3),
        fimages2::PixelFormat::R8G8B8 => Ok(3),
        fimages2::PixelFormat::I420 => Ok(1),
        fimages2::PixelFormat::M420 => Ok(1),
        fimages2::PixelFormat::Nv12 => Ok(1),
        fimages2::PixelFormat::Yuy2 => Ok(2),
        fimages2::PixelFormat::Yv12 => Ok(1),
        fimages2::PixelFormat::R5G6B5 => Ok(2),
        fimages2::PixelFormat::R3G3B2 => Ok(1),
        fimages2::PixelFormat::R2G2B2X2 => Ok(1),
        fimages2::PixelFormat::L8 => Ok(1),
        fimages2::PixelFormat::R8 => Ok(1),
        fimages2::PixelFormat::R8G8 => Ok(2),
        fimages2::PixelFormat::A2B10G10R10 => Ok(4),
        fimages2::PixelFormat::A2R10G10B10 => Ok(4),
        fimages2::PixelFormat::P010 => Ok(2),
        _ => Err(format_err!(
            "stride_bytes_per_width_pixel not available for pixel_format: {:?}",
            pixel_format
        )),
    }
}

pub fn image_format_stride_bytes_per_width_pixel(pixel_format: &fsysmem::PixelFormat) -> u32 {
    match pixel_format.type_ {
        fsysmem::PixelFormatType::Invalid
        | fsysmem::PixelFormatType::Mjpeg
        | fsysmem::PixelFormatType::DoNotCare => 0,
        fsysmem::PixelFormatType::R8G8B8A8 => 4,
        fsysmem::PixelFormatType::Bgra32 => 4,
        fsysmem::PixelFormatType::Bgr24 => 3,
        fsysmem::PixelFormatType::I420 => 1,
        fsysmem::PixelFormatType::M420 => 1,
        fsysmem::PixelFormatType::Nv12 => 1,
        fsysmem::PixelFormatType::Yuy2 => 2,
        fsysmem::PixelFormatType::Yv12 => 1,
        fsysmem::PixelFormatType::Rgb565 => 2,
        fsysmem::PixelFormatType::Rgb332 => 1,
        fsysmem::PixelFormatType::Rgb2220 => 1,
        fsysmem::PixelFormatType::L8 => 1,
        fsysmem::PixelFormatType::R8 => 1,
        fsysmem::PixelFormatType::R8G8 => 2,
        fsysmem::PixelFormatType::A2B10G10R10 => 4,
        fsysmem::PixelFormatType::A2R10G10B10 => 4,
    }
}

pub fn sysmem1_pixel_format_type_from_images2_pixel_format(
    pixel_format: fimages2::PixelFormat,
) -> Result<fsysmem::PixelFormatType, Error> {
    fsysmem::PixelFormatType::from_primitive(pixel_format.into_primitive())
        .ok_or_else(|| format_err!("pixel_format not convertible to sysmem1: {:?}", pixel_format))
}

pub fn images2_pixel_format_from_sysmem_pixel_format_type(
    pixel_format: fsysmem::PixelFormatType,
) -> Result<fimages2::PixelFormat, Error> {
    fimages2::PixelFormat::from_primitive(pixel_format.into_primitive())
        .ok_or_else(|| format_err!("pixel_format not convertible to images2: {:?}", pixel_format))
}

pub fn sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
    pixel_format_modifier: fimages2::PixelFormatModifier,
) -> u64 {
    if pixel_format_modifier == fimages2::PixelFormatModifier::GoogleGoldfishOptimal {
        return fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL;
    }
    pixel_format_modifier.into_primitive()
}

pub fn images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(
    pixel_format_modifier: u64,
) -> Result<fimages2::PixelFormatModifier, Error> {
    if pixel_format_modifier == fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL {
        return Ok(fimages2::PixelFormatModifier::GoogleGoldfishOptimal);
    }
    fimages2::PixelFormatModifier::from_primitive(pixel_format_modifier).ok_or_else(|| {
        format_err!("pixel_format_modifier not convertible to images2: {:?}", pixel_format_modifier)
    })
}

pub fn sysmem1_color_space_type_from_images2_color_space(
    color_space: fimages2::ColorSpace,
) -> Result<fsysmem::ColorSpaceType, Error> {
    fsysmem::ColorSpaceType::from_primitive(color_space.into_primitive())
        .ok_or_else(|| format_err!("color_space not convertible to sysmem1: {:?}", color_space))
}

pub fn images2_color_space_from_sysmem_color_space_type(
    color_space: fsysmem::ColorSpaceType,
) -> fimages2::ColorSpace {
    // This can't fail because sysmem(1) ColorSpaceType isn't flexible and all primitive values also
    // exist in images2::ColorSpace.
    fimages2::ColorSpace::from_primitive(color_space.into_primitive()).unwrap()
}

pub fn sysmem1_image_format_from_images2_image_format(
    image_format: &fimages2::ImageFormat,
) -> Result<fsysmem::ImageFormat2, Error> {
    let coded_size = image_format.size.as_ref().ok_or_else(|| format_err!("missing size"))?;
    let format_modifier = sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
        *image_format
            .pixel_format_modifier
            .as_ref()
            .unwrap_or(&fimages2::PixelFormatModifier::Linear),
    );
    // bytes_per_row 0 is only to be used by tiled formats; not intended to be optional for
    // PixelFormatModifier::Linear
    let bytes_per_row = match format_modifier {
        fsysmem::FORMAT_MODIFIER_LINEAR => {
            // bytes_per_row required
            *image_format
                .bytes_per_row
                .as_ref()
                .ok_or_else(|| format_err!("missing bytes_per_row (required when Linear)"))?
        }
        _ => {
            // bytes_per_row can be un-set for tiled formats (un-set is preferred over 0 in images2, but we also allow 0 here)
            *image_format.bytes_per_row.as_ref().unwrap_or(&0)
        }
    };
    let display_rect = image_format.display_rect.as_ref();
    let color_space_type = sysmem1_color_space_type_from_images2_color_space(
        *image_format.color_space.as_ref().ok_or_else(|| format_err!("missing color_space"))?,
    )?;
    let pixel_aspect_ratio = image_format.pixel_aspect_ratio.as_ref();
    Ok(fsysmem::ImageFormat2 {
        pixel_format: fsysmem::PixelFormat {
            type_: sysmem1_pixel_format_type_from_images2_pixel_format(
                *image_format
                    .pixel_format
                    .as_ref()
                    .ok_or_else(|| format_err!("missing pixel_format"))?,
            )?,
            // Semantically it should be safe to always set has_format_modifier true, but we
            // preserve the "has" aspect here just in case any client code / test code is expecting
            // to see false.
            has_format_modifier: image_format.pixel_format_modifier.is_some(),
            format_modifier: fsysmem::FormatModifier { value: format_modifier },
        },
        coded_width: coded_size.width,
        coded_height: coded_size.height,
        bytes_per_row,
        display_width: display_rect.map(|rect| rect.width).unwrap_or(0),
        display_height: display_rect.map(|rect| rect.height).unwrap_or(0),
        layers: 1,
        color_space: fsysmem::ColorSpace { type_: color_space_type },
        has_pixel_aspect_ratio: pixel_aspect_ratio.is_some(),
        pixel_aspect_ratio_width: pixel_aspect_ratio.map(|size| size.width).unwrap_or(0),
        pixel_aspect_ratio_height: pixel_aspect_ratio.map(|size| size.height).unwrap_or(0),
    })
}

pub fn images2_image_format_from_sysmem_image_format(
    image_format: &fsysmem::ImageFormat2,
) -> Result<fimages2::ImageFormat, Error> {
    let pixel_format_modifier = if image_format.pixel_format.has_format_modifier {
        Some(images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(
            image_format.pixel_format.format_modifier.value,
        )?)
    } else {
        None
    };
    let display_rect = if image_format.display_width != 0 || image_format.display_height != 0 {
        let display_width = if image_format.display_width != 0 {
            image_format.display_width
        } else {
            image_format.coded_width
        };
        let display_height = if image_format.display_height != 0 {
            image_format.display_height
        } else {
            image_format.coded_height
        };
        Some(RectU { x: 0, y: 0, width: display_width, height: display_height })
    } else {
        None
    };
    let pixel_aspect_ratio = if image_format.has_pixel_aspect_ratio {
        Some(SizeU {
            width: image_format.pixel_aspect_ratio_width,
            height: image_format.pixel_aspect_ratio_height,
        })
    } else {
        None
    };
    Ok(fimages2::ImageFormat {
        pixel_format: Some(images2_pixel_format_from_sysmem_pixel_format_type(
            image_format.pixel_format.type_,
        )?),
        pixel_format_modifier,
        color_space: Some(images2_color_space_from_sysmem_color_space_type(
            image_format.color_space.type_,
        )),
        size: Some(SizeU { width: image_format.coded_width, height: image_format.coded_height }),
        bytes_per_row: Some(image_format.bytes_per_row),
        display_rect,
        pixel_aspect_ratio,
        ..Default::default()
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use fidl_fuchsia_math as fmath;

    #[test]
    fn test_linear_row_bytes_2() {
        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::B8G8R8A8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            ..Default::default()
        };

        assert_eq!(image_format_minimum_row_bytes_2(&constraints, 17).unwrap(), 4 * 24);

        assert!(image_format_minimum_row_bytes_2(&constraints, 11).is_err());
        assert!(image_format_minimum_row_bytes_2(&constraints, 101).is_err());
    }

    #[test]
    fn test_linear_row_bytes() {
        let linear = fsysmem::PixelFormat {
            type_: fsysmem::PixelFormatType::Bgra32,
            has_format_modifier: true,
            format_modifier: fsysmem::FormatModifier { value: fsysmem::FORMAT_MODIFIER_LINEAR },
        };

        let constraints = fsysmem::ImageFormatConstraints {
            pixel_format: linear,
            min_coded_width: 12,
            max_coded_width: 100,
            bytes_per_row_divisor: 4 * 8,
            max_bytes_per_row: 100000,
            ..IMAGE_FORMAT_CONSTRAINTS_DEFAULT
        };

        assert_eq!(image_format_minimum_row_bytes(&constraints, 17).unwrap(), 4 * 24);

        assert!(image_format_minimum_row_bytes(&constraints, 11).is_err());
        assert!(image_format_minimum_row_bytes(&constraints, 101).is_err());
    }

    #[test]
    fn plane_byte_offset_2() {
        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::B8G8R8A8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            ..Default::default()
        };

        let image_format = constraints_to_image_format(&constraints, 18, 17).unwrap();
        // The raw size would be 72 without bytes_per_row_divisor of 32.
        assert_eq!(*image_format.bytes_per_row.as_ref().unwrap(), 96);

        assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 0);
        assert!(image_format_plane_byte_offset_2(&image_format, 1).is_err());

        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::I420),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            ..Default::default()
        };

        const BYTES_PER_ROW: u32 = 32;
        let image_format = constraints_to_image_format(&constraints, 18, 20).unwrap();
        assert_eq!(*image_format.bytes_per_row.as_ref().unwrap(), BYTES_PER_ROW);

        assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 0);
        assert_eq!(image_format_plane_byte_offset_2(&image_format, 1).unwrap(), BYTES_PER_ROW * 20);
        assert_eq!(
            image_format_plane_byte_offset_2(&image_format, 2).unwrap(),
            BYTES_PER_ROW * 20 + BYTES_PER_ROW / 2 * 20 / 2
        );
        assert!(image_format_plane_byte_offset_2(&image_format, 3).is_err());

        assert_eq!(get_plane_row_bytes_2(&image_format, 0).unwrap(), BYTES_PER_ROW);
        assert_eq!(get_plane_row_bytes_2(&image_format, 1).unwrap(), BYTES_PER_ROW / 2);
        assert_eq!(get_plane_row_bytes_2(&image_format, 2).unwrap(), BYTES_PER_ROW / 2);
        assert!(get_plane_row_bytes_2(&image_format, 3).is_err())
    }

    #[test]
    fn plane_byte_offset() {
        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::B8G8R8A8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            ..Default::default()
        };

        let image_format = constraints_to_image_format(&constraints, 18, 17).unwrap();
        // The raw size would be 72 without bytes_per_row_divisor of 32.
        assert_eq!(*image_format.bytes_per_row.as_ref().unwrap(), 96);

        assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 0);
        assert!(image_format_plane_byte_offset_2(&image_format, 1).is_err());

        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::I420),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            ..Default::default()
        };

        const BYTES_PER_ROW: u32 = 32;
        let image_format = constraints_to_image_format(&constraints, 18, 20).unwrap();
        assert_eq!(*image_format.bytes_per_row.as_ref().unwrap(), BYTES_PER_ROW);

        assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 0);
        assert_eq!(image_format_plane_byte_offset_2(&image_format, 1).unwrap(), BYTES_PER_ROW * 20);
        assert_eq!(
            image_format_plane_byte_offset_2(&image_format, 2).unwrap(),
            BYTES_PER_ROW * 20 + BYTES_PER_ROW / 2 * 20 / 2
        );
        assert!(image_format_plane_byte_offset_2(&image_format, 3).is_err());

        assert_eq!(get_plane_row_bytes_2(&image_format, 0).unwrap(), BYTES_PER_ROW);
        assert_eq!(get_plane_row_bytes_2(&image_format, 1).unwrap(), BYTES_PER_ROW / 2);
        assert_eq!(get_plane_row_bytes_2(&image_format, 2).unwrap(), BYTES_PER_ROW / 2);
        assert!(get_plane_row_bytes_2(&image_format, 3).is_err())
    }

    #[test]
    fn test_constraints_to_image_format() {
        // The fields set to 37 are intentionally checking that those fields are ignored by the
        // conversion, at least for now.
        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::R8G8B8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::Linear),
            min_size: Some(SizeU { width: 12, height: 12 }),
            max_size: Some(SizeU { width: 100, height: 100 }),
            bytes_per_row_divisor: Some(4 * 8),
            max_bytes_per_row: Some(100000),
            color_spaces: Some(vec![fimages2::ColorSpace::Rec709]),
            min_bytes_per_row: Some(24),
            max_width_times_height: Some(12 * 12),
            size_alignment: Some(fmath::SizeU { width: 37, height: 1 }),
            display_rect_alignment: Some(fmath::SizeU { width: 37, height: 37 }),
            required_min_size: Some(fmath::SizeU { width: 37, height: 37 }),
            required_max_size: Some(fmath::SizeU { width: 37, height: 37 }),
            start_offset_divisor: Some(37),
            pixel_format_and_modifiers: Some(vec![fsysmem2::PixelFormatAndModifier {
                pixel_format: fimages2::PixelFormat::Yv12,
                pixel_format_modifier: fimages2::PixelFormatModifier::GoogleGoldfishOptimal,
            }]),
            require_bytes_per_row_at_pixel_boundary: Some(true),
            ..Default::default()
        };

        let image_format = constraints_to_image_format(&constraints, 18, 17).unwrap();

        assert_eq!(image_format.pixel_format, Some(fimages2::PixelFormat::R8G8B8));
        assert_eq!(image_format.pixel_format_modifier, Some(fimages2::PixelFormatModifier::Linear));
        assert_eq!(image_format.color_space, Some(fimages2::ColorSpace::Rec709));
        assert_eq!(image_format.size, Some(fmath::SizeU { width: 18, height: 17 }));
        assert_eq!(image_format.bytes_per_row, Some(96));

        // We intentionally want these to be None when we don't have any explicit info for them.
        assert_eq!(image_format.display_rect, None);
        assert_eq!(image_format.valid_size, None);
        assert_eq!(image_format.pixel_aspect_ratio, None);
    }

    #[test]
    fn test_image_format_stride_bytes_per_width_pixel_2() {
        assert_eq!(
            4,
            image_format_stride_bytes_per_width_pixel_2(fimages2::PixelFormat::R8G8B8A8).unwrap()
        );
        assert!(
            image_format_stride_bytes_per_width_pixel_2(fimages2::PixelFormat::DoNotCare).is_err()
        );
    }

    #[test]
    fn test_sysmem1_pixel_format_type_from_images2_pixel_format() {
        assert_eq!(
            fsysmem::PixelFormatType::Bgra32,
            sysmem1_pixel_format_type_from_images2_pixel_format(fimages2::PixelFormat::B8G8R8A8)
                .unwrap()
        );
        assert!(
            sysmem1_pixel_format_type_from_images2_pixel_format(
                fimages2::PixelFormat::from_primitive_allow_unknown(1189673091)
            )
            .is_err()
        );
    }

    #[test]
    fn test_sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier() {
        assert_eq!(
            fsysmem::FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TE_TILED_HEADER,
            sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
                fimages2::PixelFormatModifier::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader
            )
        );
        assert_eq!(
            fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL,
            sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
                fimages2::PixelFormatModifier::GoogleGoldfishOptimal
            )
        );
        assert_eq!(
            fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL,
            sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
                fimages2::PixelFormatModifier::from_primitive_allow_unknown(
                    fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL
                )
            )
        );
        // We intentionally allow too-new values to convert.
        assert_eq!(
            1189673091,
            sysmem1_pixel_format_modifier_from_images2_pixel_format_modifier(
                fimages2::PixelFormatModifier::from_primitive_allow_unknown(1189673091)
            )
        );
    }

    #[test]
    fn test_images2_pixel_format_from_sysmem_pixel_format_type() {
        assert_eq!(
            fimages2::PixelFormat::B8G8R8A8,
            images2_pixel_format_from_sysmem_pixel_format_type(fsysmem::PixelFormatType::Bgra32)
                .unwrap()
        );
        assert_eq!(
            fimages2::PixelFormat::Yv12,
            images2_pixel_format_from_sysmem_pixel_format_type(fsysmem::PixelFormatType::Yv12)
                .unwrap()
        );
    }

    #[test]
    fn test_images2_pixel_format_modifier_from_sysmem_pixel_format_modifier() {
        assert_eq!(
            fimages2::PixelFormatModifier::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader,
            images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(
                fsysmem::FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TE_TILED_HEADER
            )
            .unwrap()
        );
        assert_eq!(
            fimages2::PixelFormatModifier::GoogleGoldfishOptimal,
            images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(
                fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL
            )
            .unwrap()
        );
        assert_eq!(
            fimages2::PixelFormatModifier::GoogleGoldfishOptimal,
            images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(
                fimages2::PixelFormatModifier::GoogleGoldfishOptimal.into_primitive()
            )
            .unwrap()
        );
        assert!(
            images2_pixel_format_modifier_from_sysmem_pixel_format_modifier(1189673091).is_err()
        );
    }

    #[test]
    fn test_sysmem1_color_space_type_from_images2_color_space() {
        assert_eq!(
            fsysmem::ColorSpaceType::Rec709,
            sysmem1_color_space_type_from_images2_color_space(fimages2::ColorSpace::Rec709)
                .unwrap()
        );
        assert!(
            sysmem1_color_space_type_from_images2_color_space(
                fimages2::ColorSpace::from_primitive_allow_unknown(1189673091)
            )
            .is_err()
        );
    }

    #[test]
    fn test_images2_color_space_from_sysmem_color_space_type() {
        assert_eq!(
            fimages2::ColorSpace::Rec709,
            images2_color_space_from_sysmem_color_space_type(fsysmem::ColorSpaceType::Rec709)
        );
        assert_eq!(
            fimages2::ColorSpace::Srgb,
            images2_color_space_from_sysmem_color_space_type(fsysmem::ColorSpaceType::Srgb)
        );
    }

    #[test]
    fn test_sysmem1_image_format_from_images2_image_format() {
        {
            let images2_format = fimages2::ImageFormat {
                pixel_format: Some(fimages2::PixelFormat::Yv12),
                pixel_format_modifier: None,
                color_space: Some(fimages2::ColorSpace::Rec709),
                size: Some(fmath::SizeU { width: 17, height: 13 }),
                bytes_per_row: Some(32),
                display_rect: Some(fmath::RectU { x: 0, y: 0, width: 15, height: 11 }),
                valid_size: Some(fmath::SizeU { width: 12, height: 10 }),
                pixel_aspect_ratio: Some(fmath::SizeU { width: 2, height: 3 }),
                ..Default::default()
            };

            let sysmem_format =
                sysmem1_image_format_from_images2_image_format(&images2_format).unwrap();

            assert_eq!(fsysmem::PixelFormatType::Yv12, sysmem_format.pixel_format.type_);
            assert_eq!(false, sysmem_format.pixel_format.has_format_modifier);
            assert_eq!(17, sysmem_format.coded_width);
            assert_eq!(13, sysmem_format.coded_height);
            assert_eq!(32, sysmem_format.bytes_per_row);
            assert_eq!(15, sysmem_format.display_width);
            assert_eq!(11, sysmem_format.display_height);
            assert_eq!(1, sysmem_format.layers);
            assert_eq!(fsysmem::ColorSpaceType::Rec709, sysmem_format.color_space.type_);
            assert_eq!(true, sysmem_format.has_pixel_aspect_ratio);
            assert_eq!(2, sysmem_format.pixel_aspect_ratio_width);
            assert_eq!(3, sysmem_format.pixel_aspect_ratio_height);
        }

        {
            let images2_format = fimages2::ImageFormat {
                pixel_format: Some(fimages2::PixelFormat::Yv12),
                pixel_format_modifier: Some(
                    fimages2::PixelFormatModifier::ArmAfbc16X16SplitBlockSparseYuvTeTiledHeader,
                ),
                color_space: Some(fimages2::ColorSpace::Rec709),
                size: Some(fmath::SizeU { width: 17, height: 13 }),
                bytes_per_row: Some(32),
                display_rect: Some(fmath::RectU { x: 0, y: 0, width: 15, height: 11 }),
                valid_size: Some(fmath::SizeU { width: 12, height: 10 }),
                pixel_aspect_ratio: Some(fmath::SizeU { width: 2, height: 3 }),
                ..Default::default()
            };

            let sysmem_format =
                sysmem1_image_format_from_images2_image_format(&images2_format).unwrap();

            assert_eq!(fsysmem::PixelFormatType::Yv12, sysmem_format.pixel_format.type_);
            assert_eq!(true, sysmem_format.pixel_format.has_format_modifier);
            assert_eq!(
                fsysmem::FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TE_TILED_HEADER,
                sysmem_format.pixel_format.format_modifier.value
            );
            assert_eq!(17, sysmem_format.coded_width);
            assert_eq!(13, sysmem_format.coded_height);
            assert_eq!(32, sysmem_format.bytes_per_row);
            assert_eq!(15, sysmem_format.display_width);
            assert_eq!(11, sysmem_format.display_height);
            assert_eq!(1, sysmem_format.layers);
            assert_eq!(fsysmem::ColorSpaceType::Rec709, sysmem_format.color_space.type_);
            assert_eq!(true, sysmem_format.has_pixel_aspect_ratio);
            assert_eq!(2, sysmem_format.pixel_aspect_ratio_width);
            assert_eq!(3, sysmem_format.pixel_aspect_ratio_height);
        }
    }

    #[test]
    fn test_images2_image_format_from_sysmem_image_format() {
        let sysmem_format = fsysmem::ImageFormat2 {
            pixel_format: fsysmem::PixelFormat {
                type_: fsysmem::PixelFormatType::Yv12,
                has_format_modifier: true,
                format_modifier: fsysmem::FormatModifier {
                    value: fsysmem::FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL,
                },
            },
            coded_width: 17,
            coded_height: 13,
            bytes_per_row: 32,
            display_width: 15,
            display_height: 11,
            layers: 1,
            color_space: fsysmem::ColorSpace { type_: fsysmem::ColorSpaceType::Rec709 },
            has_pixel_aspect_ratio: true,
            pixel_aspect_ratio_width: 2,
            pixel_aspect_ratio_height: 3,
        };

        let images2_format = images2_image_format_from_sysmem_image_format(&sysmem_format).unwrap();

        assert_eq!(Some(fimages2::PixelFormat::Yv12), images2_format.pixel_format);
        assert_eq!(
            Some(fimages2::PixelFormatModifier::GoogleGoldfishOptimal),
            images2_format.pixel_format_modifier
        );
        assert_eq!(Some(fimages2::ColorSpace::Rec709), images2_format.color_space);
        assert_eq!(Some(fmath::SizeU { width: 17, height: 13 }), images2_format.size);
        assert_eq!(Some(32), images2_format.bytes_per_row);
        assert_eq!(
            Some(fmath::RectU { x: 0, y: 0, width: 15, height: 11 }),
            images2_format.display_rect
        );
        assert_eq!(None, images2_format.valid_size);
        assert_eq!(Some(fmath::SizeU { width: 2, height: 3 }), images2_format.pixel_aspect_ratio);
    }

    #[test]
    fn test_pvric_tiling_data() {
        assert_eq!(
            pvric_tiling_data(fimages2::PixelFormatModifier::PvrFbcdc8X8V14),
            Some(PvricTilingData { tile_rows: 8, bytes_per_row_per_tile: 32 })
        );
        assert_eq!(
            pvric_tiling_data(fimages2::PixelFormatModifier::PvrFbcdc16X4V14),
            Some(PvricTilingData { tile_rows: 4, bytes_per_row_per_tile: 64 })
        );
        assert_eq!(pvric_tiling_data(fimages2::PixelFormatModifier::Linear), None);
    }

    #[test]
    fn test_pvric_16x4_row_bytes_and_planes() {
        let supported_32bpp_formats = [
            fimages2::PixelFormat::R8G8B8A8,
            fimages2::PixelFormat::R8G8B8X8,
            fimages2::PixelFormat::B8G8R8A8,
            fimages2::PixelFormat::B8G8R8X8,
            fimages2::PixelFormat::A2R10G10B10,
            fimages2::PixelFormat::A2B10G10R10,
        ];

        for format in supported_32bpp_formats {
            let constraints = fsysmem2::ImageFormatConstraints {
                pixel_format: Some(format),
                pixel_format_modifier: Some(fimages2::PixelFormatModifier::PvrFbcdc16X4V14),
                min_size: Some(SizeU { width: 12, height: 12 }),
                max_size: Some(SizeU { width: 100, height: 100 }),
                bytes_per_row_divisor: Some(32),
                max_bytes_per_row: Some(100000),
                ..Default::default()
            };

            // For 18x17 with divisor 32: lcm(32, 64) = 64. 18 * 4 = 72 -> rounds up to 128 bytes/row.
            // width_in_tiles = 128 / 64 = 2.
            // height_in_tiles = ceil(17 / 4) = 5.
            // num_tiles = 2 * 5 = 10.
            // header_size = RoundUp(10, 256) = 256.
            assert_eq!(image_format_minimum_row_bytes_2(&constraints, 18).unwrap(), 128);
            assert!(image_format_minimum_row_bytes_2(&constraints, 11).is_err());
            assert!(image_format_minimum_row_bytes_2(&constraints, 101).is_err());

            let image_format = constraints_to_image_format(&constraints, 18, 17).unwrap();
            assert_eq!(image_format.bytes_per_row, Some(128));

            assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 256);
            assert!(image_format_plane_byte_offset_2(&image_format, 1).is_err());
            assert!(image_format_plane_byte_offset_2(&image_format, 2).is_err());
            assert_eq!(image_format_plane_byte_offset_2(&image_format, 3).unwrap(), 0);
            assert!(image_format_plane_byte_offset_2(&image_format, 4).is_err());

            assert_eq!(get_plane_row_bytes_2(&image_format, 0).unwrap(), 128);
            assert!(get_plane_row_bytes_2(&image_format, 1).is_err());
            assert!(get_plane_row_bytes_2(&image_format, 2).is_err());
            assert_eq!(get_plane_row_bytes_2(&image_format, 3).unwrap(), 2);
            assert!(get_plane_row_bytes_2(&image_format, 4).is_err());
        }

        // Large resolution: 1280x2856 with 32-bpp B8G8R8A8 and PvrFbcdc16X4V14.
        // bytes_per_row = 1280 * 4 = 5120.
        // width_in_tiles = 5120 / 64 = 80, height_in_tiles = 2856 / 4 = 714.
        // num_tiles = 80 * 714 = 57,120.
        // header_size = RoundUp(57,120, 256) = 57,344.
        let large_constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::B8G8R8A8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::PvrFbcdc16X4V14),
            min_size: Some(SizeU { width: 1, height: 1 }),
            max_size: Some(SizeU { width: 4096, height: 4096 }),
            bytes_per_row_divisor: Some(64),
            ..Default::default()
        };
        assert_eq!(image_format_minimum_row_bytes_2(&large_constraints, 1280).unwrap(), 5120);
        let large_format = constraints_to_image_format(&large_constraints, 1280, 2856).unwrap();
        assert_eq!(large_format.bytes_per_row, Some(5120));
        assert_eq!(image_format_plane_byte_offset_2(&large_format, 0).unwrap(), 57_344);
        assert_eq!(image_format_plane_byte_offset_2(&large_format, 3).unwrap(), 0);
        assert_eq!(get_plane_row_bytes_2(&large_format, 0).unwrap(), 5120);
        assert_eq!(get_plane_row_bytes_2(&large_format, 3).unwrap(), 80);

        // 16-bpp R5G6B5 with PvrFbcdc16X4V14 (bytes_per_row_per_tile = 64, tile_rows = 4).
        // For width = 18 (36 bytes): rounds up to 64 bytes/row (1 tile wide).
        // height = 17: ceil(17 / 4) = 5 tiles high.
        // num_tiles = 1 * 5 = 5, header_size = 256.
        let rgb565_constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::R5G6B5),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::PvrFbcdc16X4V14),
            min_size: Some(SizeU { width: 1, height: 1 }),
            max_size: Some(SizeU { width: 4096, height: 4096 }),
            ..Default::default()
        };
        let rgb565_format = constraints_to_image_format(&rgb565_constraints, 18, 17).unwrap();
        assert_eq!(rgb565_format.bytes_per_row, Some(64));
        assert_eq!(image_format_plane_byte_offset_2(&rgb565_format, 0).unwrap(), 256);
        assert_eq!(image_format_plane_byte_offset_2(&rgb565_format, 3).unwrap(), 0);
        assert_eq!(get_plane_row_bytes_2(&rgb565_format, 0).unwrap(), 64);
        assert_eq!(get_plane_row_bytes_2(&rgb565_format, 3).unwrap(), 1);

        // Unsupported formats (Nv12, B8G8R8) must return Err.
        for unsupported in [fimages2::PixelFormat::Nv12, fimages2::PixelFormat::B8G8R8] {
            let bad_constraints = fsysmem2::ImageFormatConstraints {
                pixel_format: Some(unsupported),
                pixel_format_modifier: Some(fimages2::PixelFormatModifier::PvrFbcdc16X4V14),
                ..Default::default()
            };
            assert!(image_format_minimum_row_bytes_2(&bad_constraints, 64).is_err());
        }
    }

    #[test]
    fn test_pvric_8x8_row_bytes_and_planes() {
        // Test 8x8 V14 with 32-bpp at 1920x1080 (bytes_per_row_per_tile = 32, tile_rows = 8).
        // bytes_per_row = 1920 * 4 = 7680.
        // width_in_tiles = 7680 / 32 = 240.
        // height_in_tiles = 1080 / 8 = 135.
        // num_tiles = 240 * 135 = 32,400.
        // header_size = RoundUp(32,400, 256) = 32,512.
        let constraints = fsysmem2::ImageFormatConstraints {
            pixel_format: Some(fimages2::PixelFormat::R8G8B8A8),
            pixel_format_modifier: Some(fimages2::PixelFormatModifier::PvrFbcdc8X8V14),
            min_size: Some(SizeU { width: 1, height: 1 }),
            max_size: Some(SizeU { width: 4096, height: 4096 }),
            ..Default::default()
        };

        let image_format = constraints_to_image_format(&constraints, 1920, 1080).unwrap();
        assert_eq!(image_format.bytes_per_row, Some(7680));
        assert_eq!(image_format_plane_byte_offset_2(&image_format, 0).unwrap(), 32_512);
        assert!(image_format_plane_byte_offset_2(&image_format, 1).is_err());
        assert!(image_format_plane_byte_offset_2(&image_format, 2).is_err());
        assert_eq!(image_format_plane_byte_offset_2(&image_format, 3).unwrap(), 0);
        assert!(image_format_plane_byte_offset_2(&image_format, 4).is_err());

        assert_eq!(get_plane_row_bytes_2(&image_format, 0).unwrap(), 7680);
        assert!(get_plane_row_bytes_2(&image_format, 1).is_err());
        assert!(get_plane_row_bytes_2(&image_format, 2).is_err());
        assert_eq!(get_plane_row_bytes_2(&image_format, 3).unwrap(), 240);
        assert!(get_plane_row_bytes_2(&image_format, 4).is_err());
    }
}