// Copyright 2019 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.

#include <lib/fidl/llcpp/heap_allocator.h>
#include <lib/image-format-llcpp/image-format-llcpp.h>
#include <lib/image-format/image_format.h>
#include <lib/sysmem-make-tracking/make_tracking.h>
#include <lib/sysmem-version/sysmem-version.h>

#include <fbl/array.h>
#include <zxtest/zxtest.h>

#include "fuchsia/sysmem/c/fidl.h"
#include "fuchsia/sysmem/llcpp/fidl.h"
#include "fuchsia/sysmem2/llcpp/fidl.h"

namespace sysmem_v1 = llcpp::fuchsia::sysmem;
namespace sysmem_v2 = llcpp::fuchsia::sysmem2;

fidl::HeapAllocator allocator;

TEST(ImageFormat, LinearComparison_V2_LLCPP) {
  auto plain = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                   .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                   .build();

  auto linear = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                    .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                    .set_format_modifier_value(
                        sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_LINEAR))
                    .build();

  auto x_tiled = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                     .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                     .set_format_modifier_value(sysmem::MakeTracking(
                         &allocator, sysmem_v2::FORMAT_MODIFIER_INTEL_I915_X_TILED))
                     .build();

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, plain));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, linear));

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, linear));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, plain));

  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(linear, x_tiled));
  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(plain, x_tiled));
}

TEST(ImageFormat, LinearComparison_V1_LLCPP) {
  sysmem_v1::PixelFormat plain = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = false,
  };

  sysmem_v1::PixelFormat linear = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_LINEAR,
  };

  sysmem_v1::PixelFormat x_tiled = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_INTEL_I915_X_TILED,
  };

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, plain));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, linear));

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, linear));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, plain));

  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(linear, x_tiled));
  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(plain, x_tiled));
}

TEST(ImageFormat, LinearComparison_V1_C) {
  fuchsia_sysmem_PixelFormat plain = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = false,
  };

  fuchsia_sysmem_PixelFormat linear = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = fuchsia_sysmem_FORMAT_MODIFIER_LINEAR,
  };

  fuchsia_sysmem_PixelFormat x_tiled = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = fuchsia_sysmem_FORMAT_MODIFIER_INTEL_I915_X_TILED,
  };

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, plain));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, linear));

  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(plain, linear));
  EXPECT_TRUE(ImageFormatIsPixelFormatEqual(linear, plain));

  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(linear, x_tiled));
  EXPECT_FALSE(ImageFormatIsPixelFormatEqual(plain, x_tiled));
}

TEST(ImageFormat, LinearRowBytes_V2_LLCPP) {
  auto linear = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                    .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                    .set_format_modifier_value(
                        sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_LINEAR))
                    .build();
  auto constraints = allocator.make_table_builder<sysmem_v2::ImageFormatConstraints>()
                         .set_pixel_format(sysmem::MakeTracking(&allocator, std::move(linear)))
                         .set_min_coded_width(sysmem::MakeTracking(&allocator, 12u))
                         .set_max_coded_width(sysmem::MakeTracking(&allocator, 100u))
                         .set_bytes_per_row_divisor(sysmem::MakeTracking(&allocator, 4u * 8u))
                         .set_max_bytes_per_row(sysmem::MakeTracking(&allocator, 100000u))
                         .build();

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatMinimumRowBytes(constraints, 17, &row_bytes));
  EXPECT_EQ(row_bytes, 4 * 24);

  EXPECT_FALSE(ImageFormatMinimumRowBytes(constraints, 11, &row_bytes));
  EXPECT_FALSE(ImageFormatMinimumRowBytes(constraints, 101, &row_bytes));
}

TEST(ImageFormat, LinearRowBytes_V1_LLCPP) {
  sysmem_v1::PixelFormat linear = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_LINEAR,
  };
  sysmem_v1::ImageFormatConstraints constraints = {
      .pixel_format = linear,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatMinimumRowBytes(constraints, 17, &row_bytes));
  EXPECT_EQ(row_bytes, 4 * 24);

  EXPECT_FALSE(ImageFormatMinimumRowBytes(constraints, 11, &row_bytes));
  EXPECT_FALSE(ImageFormatMinimumRowBytes(constraints, 101, &row_bytes));
}

TEST(ImageFormat, LinearRowBytes_V1_C) {
  fuchsia_sysmem_PixelFormat linear = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = fuchsia_sysmem_FORMAT_MODIFIER_LINEAR,
  };
  fuchsia_sysmem_ImageFormatConstraints constraints = {
      .pixel_format = linear,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatMinimumRowBytes(&constraints, 17, &row_bytes));
  EXPECT_EQ(row_bytes, 4 * 24);

  EXPECT_FALSE(ImageFormatMinimumRowBytes(&constraints, 11, &row_bytes));
  EXPECT_FALSE(ImageFormatMinimumRowBytes(&constraints, 101, &row_bytes));
}

TEST(ImageFormat, InvalidColorSpace_V1_LLCPP) {
  auto sysmem_format_result = ImageFormatConvertZxToSysmem_v1(&allocator, ZX_PIXEL_FORMAT_RGB_565);
  EXPECT_TRUE(sysmem_format_result.is_ok());
  auto sysmem_format = sysmem_format_result.take_value();

  sysmem_v1::ColorSpace color_space{sysmem_v1::ColorSpaceType::INVALID};
  // Shouldn't crash.
  EXPECT_FALSE(ImageFormatIsSupportedColorSpaceForPixelFormat(color_space, sysmem_format));
}

TEST(ImageFormat, ZxPixelFormat_V2_LLCPP) {
  zx_pixel_format_t pixel_formats[] = {
      ZX_PIXEL_FORMAT_RGB_565,   ZX_PIXEL_FORMAT_RGB_332,  ZX_PIXEL_FORMAT_RGB_2220,
      ZX_PIXEL_FORMAT_ARGB_8888, ZX_PIXEL_FORMAT_RGB_x888, ZX_PIXEL_FORMAT_MONO_8,
      ZX_PIXEL_FORMAT_GRAY_8,    ZX_PIXEL_FORMAT_NV12,     ZX_PIXEL_FORMAT_RGB_888,
  };
  for (zx_pixel_format_t format : pixel_formats) {
    fprintf(stderr, "Format %x\n", format);
    auto sysmem_format_result = ImageFormatConvertZxToSysmem_v2(&allocator, format);
    EXPECT_TRUE(sysmem_format_result.is_ok());
    sysmem_v2::PixelFormat sysmem_format = sysmem_format_result.take_value().build();
    zx_pixel_format_t back_format;
    EXPECT_TRUE(ImageFormatConvertSysmemToZx(sysmem_format, &back_format));
    if (format == ZX_PIXEL_FORMAT_RGB_x888) {
      EXPECT_EQ(ZX_PIXEL_FORMAT_ARGB_8888, back_format);
    } else {
      EXPECT_EQ(back_format, format);
    }
    EXPECT_TRUE(sysmem_format.has_format_modifier_value());
    EXPECT_EQ(sysmem_v2::FORMAT_MODIFIER_LINEAR,
              static_cast<uint64_t>(sysmem_format.format_modifier_value()));

    auto color_space_builder = allocator.make_table_builder<sysmem_v2::ColorSpace>();
    if (format == ZX_PIXEL_FORMAT_NV12) {
      color_space_builder.set_type(
          sysmem::MakeTracking(&allocator, sysmem_v2::ColorSpaceType::REC601_NTSC));
    } else {
      color_space_builder.set_type(
          sysmem::MakeTracking(&allocator, sysmem_v2::ColorSpaceType::SRGB));
    }
    auto color_space = color_space_builder.build();
    EXPECT_TRUE(ImageFormatIsSupportedColorSpaceForPixelFormat(color_space, sysmem_format));

    EXPECT_EQ(ZX_PIXEL_FORMAT_BYTES(format), ImageFormatStrideBytesPerWidthPixel(sysmem_format));
    EXPECT_TRUE(ImageFormatIsSupported(sysmem_format));
    EXPECT_LT(0u, ImageFormatBitsPerPixel(sysmem_format));
  }

  auto other_format =
      allocator.make_table_builder<sysmem_v2::PixelFormat>()
          .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
          .set_format_modifier_value(
              sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_INTEL_I915_X_TILED))
          .build();

  zx_pixel_format_t back_format;
  EXPECT_FALSE(ImageFormatConvertSysmemToZx(other_format, &back_format));
  // Treat as linear.
  auto other_format2 = sysmem::V2ClonePixelFormat(&allocator, other_format)
                           .set_format_modifier_value(nullptr)
                           .build();
  EXPECT_TRUE(ImageFormatConvertSysmemToZx(other_format2, &back_format));
}

TEST(ImageFormat, ZxPixelFormat_V1_LLCPP) {
  zx_pixel_format_t pixel_formats[] = {
      ZX_PIXEL_FORMAT_RGB_565,   ZX_PIXEL_FORMAT_RGB_332,  ZX_PIXEL_FORMAT_RGB_2220,
      ZX_PIXEL_FORMAT_ARGB_8888, ZX_PIXEL_FORMAT_RGB_x888, ZX_PIXEL_FORMAT_MONO_8,
      ZX_PIXEL_FORMAT_GRAY_8,    ZX_PIXEL_FORMAT_NV12,     ZX_PIXEL_FORMAT_RGB_888,
  };
  for (zx_pixel_format_t format : pixel_formats) {
    fprintf(stderr, "Format %x\n", format);
    auto sysmem_format_result = ImageFormatConvertZxToSysmem_v1(&allocator, format);
    EXPECT_TRUE(sysmem_format_result.is_ok());
    auto sysmem_format = sysmem_format_result.take_value();
    zx_pixel_format_t back_format;
    EXPECT_TRUE(ImageFormatConvertSysmemToZx(sysmem_format, &back_format));
    if (format == ZX_PIXEL_FORMAT_RGB_x888) {
      EXPECT_EQ(ZX_PIXEL_FORMAT_ARGB_8888, back_format);
    } else {
      EXPECT_EQ(back_format, format);
    }
    EXPECT_TRUE(sysmem_format.has_format_modifier);
    EXPECT_EQ(fuchsia_sysmem_FORMAT_MODIFIER_LINEAR,
              static_cast<uint64_t>(sysmem_format.format_modifier.value));

    sysmem_v1::ColorSpace color_space;
    if (format == ZX_PIXEL_FORMAT_NV12) {
      color_space.type = sysmem_v1::ColorSpaceType::REC601_NTSC;
    } else {
      color_space.type = sysmem_v1::ColorSpaceType::SRGB;
    }
    EXPECT_TRUE(ImageFormatIsSupportedColorSpaceForPixelFormat(color_space, sysmem_format));

    EXPECT_EQ(ZX_PIXEL_FORMAT_BYTES(format), ImageFormatStrideBytesPerWidthPixel(sysmem_format));
    EXPECT_TRUE(ImageFormatIsSupported(sysmem_format));
    EXPECT_LT(0u, ImageFormatBitsPerPixel(sysmem_format));
  }

  sysmem_v1::PixelFormat other_format = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_INTEL_I915_X_TILED,
  };

  zx_pixel_format_t back_format;
  EXPECT_FALSE(ImageFormatConvertSysmemToZx(other_format, &back_format));
  // Treat as linear.
  other_format.has_format_modifier = false;
  EXPECT_TRUE(ImageFormatConvertSysmemToZx(other_format, &back_format));
}

TEST(ImageFormat, ZxPixelFormat_V1_C) {
  zx_pixel_format_t pixel_formats[] = {
      ZX_PIXEL_FORMAT_RGB_565,   ZX_PIXEL_FORMAT_RGB_332,  ZX_PIXEL_FORMAT_RGB_2220,
      ZX_PIXEL_FORMAT_ARGB_8888, ZX_PIXEL_FORMAT_RGB_x888, ZX_PIXEL_FORMAT_MONO_8,
      ZX_PIXEL_FORMAT_GRAY_8,    ZX_PIXEL_FORMAT_NV12,     ZX_PIXEL_FORMAT_RGB_888,
  };
  for (zx_pixel_format_t format : pixel_formats) {
    fprintf(stderr, "Format %x\n", format);
    fuchsia_sysmem_PixelFormat sysmem_format;
    EXPECT_TRUE(ImageFormatConvertZxToSysmem(format, &sysmem_format));
    zx_pixel_format_t back_format;
    EXPECT_TRUE(ImageFormatConvertSysmemToZx(&sysmem_format, &back_format));
    if (format == ZX_PIXEL_FORMAT_RGB_x888) {
      EXPECT_EQ(ZX_PIXEL_FORMAT_ARGB_8888, back_format);
    } else {
      EXPECT_EQ(back_format, format);
    }
    EXPECT_TRUE(sysmem_format.has_format_modifier);
    EXPECT_EQ(fuchsia_sysmem_FORMAT_MODIFIER_LINEAR,
              static_cast<uint64_t>(sysmem_format.format_modifier.value));

    fuchsia_sysmem_ColorSpace color_space;
    if (format == ZX_PIXEL_FORMAT_NV12) {
      color_space.type = fuchsia_sysmem_ColorSpaceType_REC601_NTSC;
    } else {
      color_space.type = fuchsia_sysmem_ColorSpaceType_SRGB;
    }
    EXPECT_TRUE(ImageFormatIsSupportedColorSpaceForPixelFormat(color_space, sysmem_format));

    EXPECT_EQ(ZX_PIXEL_FORMAT_BYTES(format), ImageFormatStrideBytesPerWidthPixel(&sysmem_format));
    EXPECT_TRUE(ImageFormatIsSupported(&sysmem_format));
    EXPECT_LT(0u, ImageFormatBitsPerPixel(&sysmem_format));
  }

  fuchsia_sysmem_PixelFormat other_format = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = fuchsia_sysmem_FORMAT_MODIFIER_INTEL_I915_X_TILED,
  };

  zx_pixel_format_t back_format;
  EXPECT_FALSE(ImageFormatConvertSysmemToZx(&other_format, &back_format));
  // Treat as linear.
  other_format.has_format_modifier = false;
  EXPECT_TRUE(ImageFormatConvertSysmemToZx(&other_format, &back_format));
}

TEST(ImageFormat, PlaneByteOffset_V2_LLCPP) {
  auto linear = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                    .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                    .set_format_modifier_value(
                        sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_LINEAR))
                    .build();
  auto constraints = allocator.make_table_builder<sysmem_v2::ImageFormatConstraints>()
                         .set_pixel_format(sysmem::MakeTracking(&allocator, std::move(linear)))
                         .set_min_coded_width(sysmem::MakeTracking(&allocator, 12u))
                         .set_max_coded_width(sysmem::MakeTracking(&allocator, 100u))
                         .set_min_coded_height(sysmem::MakeTracking(&allocator, 12u))
                         .set_max_coded_height(sysmem::MakeTracking(&allocator, 100u))
                         .set_bytes_per_row_divisor(sysmem::MakeTracking(&allocator, 4u * 8u))
                         .set_max_bytes_per_row(sysmem::MakeTracking(&allocator, 100000u))
                         .build();

  auto image_format_result = ImageConstraintsToFormat(&allocator, constraints, 18, 17);
  EXPECT_TRUE(image_format_result.is_ok());
  auto image_format = image_format_result.take_value().build();
  // The raw size would be 72 without bytes_per_row_divisor of 32.
  EXPECT_EQ(96u, image_format.bytes_per_row());

  uint64_t byte_offset;
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(image_format, 1, &byte_offset));

  auto constraints2_builder = sysmem::V2CloneImageFormatConstraints(&allocator, constraints);
  constraints2_builder.get_builder_pixel_format().set_type(
      sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::I420));
  auto constraints2 = constraints2_builder.build();

  constexpr uint32_t kBytesPerRow = 32;
  image_format_result = ImageConstraintsToFormat(&allocator, constraints2, 18, 20);
  EXPECT_TRUE(image_format_result.is_ok());
  image_format = image_format_result.take_value().build();
  EXPECT_EQ(kBytesPerRow, image_format.bytes_per_row());
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 1, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 2, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20 + kBytesPerRow / 2 * 20 / 2, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(image_format, 3, &byte_offset));

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 0, &row_bytes));
  EXPECT_EQ(kBytesPerRow, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 1, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 2, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_FALSE(ImageFormatPlaneRowBytes(image_format, 3, &row_bytes));
}

TEST(ImageFormat, PlaneByteOffset_V1_LLCPP) {
  sysmem_v1::PixelFormat linear = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_LINEAR,
  };
  sysmem_v1::ImageFormatConstraints constraints = {
      .pixel_format = linear,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .min_coded_height = 12,
      .max_coded_height = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  auto image_format_result = ImageConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(image_format_result.is_ok());
  auto image_format = image_format_result.take_value();
  // The raw size would be 72 without bytes_per_row_divisor of 32.
  EXPECT_EQ(96u, image_format.bytes_per_row);

  uint64_t byte_offset;
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(image_format, 1, &byte_offset));

  constraints.pixel_format.type = sysmem_v1::PixelFormatType::I420;

  constexpr uint32_t kBytesPerRow = 32;
  image_format_result = ImageConstraintsToFormat(constraints, 18, 20);
  EXPECT_TRUE(image_format_result.is_ok());
  image_format = image_format_result.take_value();
  EXPECT_EQ(kBytesPerRow, image_format.bytes_per_row);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 1, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 2, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20 + kBytesPerRow / 2 * 20 / 2, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(image_format, 3, &byte_offset));

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 0, &row_bytes));
  EXPECT_EQ(kBytesPerRow, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 1, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 2, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_FALSE(ImageFormatPlaneRowBytes(image_format, 3, &row_bytes));
}

TEST(ImageFormat, PlaneByteOffset_V1_C) {
  fuchsia_sysmem_PixelFormat linear = {
      .type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = fuchsia_sysmem_FORMAT_MODIFIER_LINEAR,
  };
  fuchsia_sysmem_ImageFormatConstraints constraints = {
      .pixel_format = linear,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .min_coded_height = 12,
      .max_coded_height = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  fuchsia_sysmem_ImageFormat_2 image_format;
  EXPECT_TRUE(ImageConstraintsToFormat(&constraints, 18, 17, &image_format));
  // The raw size would be 72 without bytes_per_row_divisor of 32.
  EXPECT_EQ(96u, image_format.bytes_per_row);

  uint64_t byte_offset;
  EXPECT_TRUE(ImageFormatPlaneByteOffset(&image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(&image_format, 1, &byte_offset));

  constraints.pixel_format.type = fuchsia_sysmem_PixelFormatType_I420;

  constexpr uint32_t kBytesPerRow = 32;
  EXPECT_TRUE(ImageConstraintsToFormat(&constraints, 18, 20, &image_format));
  EXPECT_EQ(kBytesPerRow, image_format.bytes_per_row);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(&image_format, 0, &byte_offset));
  EXPECT_EQ(0u, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(&image_format, 1, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20, byte_offset);
  EXPECT_TRUE(ImageFormatPlaneByteOffset(&image_format, 2, &byte_offset));
  EXPECT_EQ(kBytesPerRow * 20 + kBytesPerRow / 2 * 20 / 2, byte_offset);
  EXPECT_FALSE(ImageFormatPlaneByteOffset(&image_format, 3, &byte_offset));

  uint32_t row_bytes;
  EXPECT_TRUE(ImageFormatPlaneRowBytes(&image_format, 0, &row_bytes));
  EXPECT_EQ(kBytesPerRow, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(&image_format, 1, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(&image_format, 2, &row_bytes));
  EXPECT_EQ(kBytesPerRow / 2, row_bytes);
  EXPECT_FALSE(ImageFormatPlaneRowBytes(&image_format, 3, &row_bytes));
}

TEST(ImageFormat, TransactionEliminationFormats_V2_LLCPP) {
  auto format = allocator.make_table_builder<sysmem_v2::PixelFormat>()
                    .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                    .set_format_modifier_value(
                        sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_LINEAR))
                    .build();
  EXPECT_TRUE(ImageFormatCompatibleWithProtectedMemory(format));

  auto format2 = sysmem::V2ClonePixelFormat(&allocator, format)
                     .set_format_modifier_value(
                         sysmem::MakeTracking(&allocator, sysmem_v2::FORMAT_MODIFIER_ARM_LINEAR_TE))
                     .build();
  EXPECT_FALSE(ImageFormatCompatibleWithProtectedMemory(format2));

  auto constraints = allocator.make_table_builder<sysmem_v2::ImageFormatConstraints>()
                         .set_pixel_format(sysmem::MakeTracking(&allocator, std::move(format2)))
                         .set_min_coded_width(sysmem::MakeTracking(&allocator, 12u))
                         .set_max_coded_width(sysmem::MakeTracking(&allocator, 100u))
                         .set_min_coded_height(sysmem::MakeTracking(&allocator, 12u))
                         .set_max_coded_height(sysmem::MakeTracking(&allocator, 100u))
                         .set_bytes_per_row_divisor(sysmem::MakeTracking(&allocator, 4u * 8u))
                         .set_max_bytes_per_row(sysmem::MakeTracking(&allocator, 100000u))
                         .build();

  auto image_format_result = ImageConstraintsToFormat(&allocator, constraints, 18, 17);
  EXPECT_TRUE(image_format_result.is_ok());
  auto image_format = image_format_result.take_value().build();
  // The raw size would be 72 without bytes_per_row_divisor of 32.
  EXPECT_EQ(96u, image_format.bytes_per_row());

  // Check the color plane data.
  uint32_t row_bytes;
  uint64_t plane_offset;
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, 0, &plane_offset));
  EXPECT_EQ(0u, plane_offset);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, 0, &row_bytes));
  EXPECT_EQ(image_format.bytes_per_row(), row_bytes);

  constexpr uint32_t kTePlane = 3;
  // Check the TE plane data.
  EXPECT_TRUE(ImageFormatPlaneByteOffset(image_format, kTePlane, &plane_offset));
  EXPECT_LE(image_format.bytes_per_row() * 17, plane_offset);
  EXPECT_TRUE(ImageFormatPlaneRowBytes(image_format, kTePlane, &row_bytes));

  // Row size should be rounded up to 64 bytes.
  EXPECT_EQ(64, row_bytes);
}

TEST(ImageFormat, TransactionEliminationFormats_V1_LLCPP) {
  sysmem_v1::PixelFormat format = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_LINEAR,
  };
  EXPECT_TRUE(image_format::FormatCompatibleWithProtectedMemory(format));
  EXPECT_TRUE(ImageFormatCompatibleWithProtectedMemory(format));

  format.format_modifier.value = sysmem_v1::FORMAT_MODIFIER_ARM_LINEAR_TE;
  EXPECT_FALSE(image_format::FormatCompatibleWithProtectedMemory(format));
  EXPECT_FALSE(ImageFormatCompatibleWithProtectedMemory(format));

  sysmem_v1::ImageFormatConstraints constraints = {
      .pixel_format = format,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .min_coded_height = 12,
      .max_coded_height = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  auto optional_format = image_format::ConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(optional_format);
  auto& image_format = *optional_format;
  // The raw size would be 72 without bytes_per_row_divisor of 32.
  EXPECT_EQ(96u, image_format.bytes_per_row);

  // Check the color plane data.
  uint32_t row_bytes;
  uint64_t plane_offset;
  EXPECT_TRUE(image_format::GetPlaneByteOffset(image_format, 0, &plane_offset));
  EXPECT_EQ(0u, plane_offset);
  EXPECT_TRUE(image_format::GetPlaneRowBytes(image_format, 0, &row_bytes));
  EXPECT_EQ(image_format.bytes_per_row, row_bytes);

  constexpr uint32_t kTePlane = 3;
  // Check the TE plane data.
  EXPECT_TRUE(image_format::GetPlaneByteOffset(image_format, kTePlane, &plane_offset));
  EXPECT_LE(image_format.bytes_per_row * 17, plane_offset);
  EXPECT_TRUE(image_format::GetPlaneRowBytes(image_format, kTePlane, &row_bytes));

  // Row size should be rounded up to 64 bytes.
  EXPECT_EQ(64, row_bytes);
}

TEST(ImageFormat, BasicSizes_V2_LLCPP) {
  constexpr uint32_t kWidth = 64;
  constexpr uint32_t kHeight = 128;
  constexpr uint32_t kStride = kWidth * 6;

  auto image_format_bgra32 =
      allocator.make_table_builder<sysmem_v2::ImageFormat>()
          .set_pixel_format(sysmem::MakeTracking(
              &allocator,
              allocator.make_table_builder<sysmem_v2::PixelFormat>()
                  .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::BGRA32))
                  .build()))
          .set_coded_width(sysmem::MakeTracking(&allocator, kWidth))
          .set_coded_height(sysmem::MakeTracking(&allocator, kHeight))
          .set_bytes_per_row(sysmem::MakeTracking(&allocator, kStride))
          .build();
  EXPECT_EQ(kHeight * kStride, ImageFormatImageSize(image_format_bgra32));
  EXPECT_EQ(1, ImageFormatCodedWidthMinDivisor(image_format_bgra32.pixel_format()));
  EXPECT_EQ(1, ImageFormatCodedHeightMinDivisor(image_format_bgra32.pixel_format()));
  EXPECT_EQ(4, ImageFormatSampleAlignment(image_format_bgra32.pixel_format()));

  auto image_format_nv12 =
      allocator.make_table_builder<sysmem_v2::ImageFormat>()
          .set_pixel_format(sysmem::MakeTracking(
              &allocator,
              allocator.make_table_builder<sysmem_v2::PixelFormat>()
                  .set_type(sysmem::MakeTracking(&allocator, sysmem_v2::PixelFormatType::NV12))
                  .build()))
          .set_coded_width(sysmem::MakeTracking(&allocator, kWidth))
          .set_coded_height(sysmem::MakeTracking(&allocator, kHeight))
          .set_bytes_per_row(sysmem::MakeTracking(&allocator, kStride))
          .build();
  EXPECT_EQ(kHeight * kStride * 3 / 2, ImageFormatImageSize(image_format_nv12));
  EXPECT_EQ(2, ImageFormatCodedWidthMinDivisor(image_format_nv12.pixel_format()));
  EXPECT_EQ(2, ImageFormatCodedHeightMinDivisor(image_format_nv12.pixel_format()));
  EXPECT_EQ(2, ImageFormatSampleAlignment(image_format_nv12.pixel_format()));
}

TEST(ImageFormat, BasicSizes_V1_LLCPP) {
  constexpr uint32_t kWidth = 64;
  constexpr uint32_t kHeight = 128;
  constexpr uint32_t kStride = 256;

  sysmem_v1::ImageFormat_2 image_format_bgra32 = {
      .pixel_format.type = sysmem_v1::PixelFormatType::BGRA32,
      .coded_width = kWidth,
      .coded_height = kHeight,
      .bytes_per_row = kStride,
  };
  EXPECT_EQ(kHeight * kStride, ImageFormatImageSize(image_format_bgra32));
  EXPECT_EQ(1, ImageFormatCodedWidthMinDivisor(image_format_bgra32.pixel_format));
  EXPECT_EQ(1, ImageFormatCodedHeightMinDivisor(image_format_bgra32.pixel_format));
  EXPECT_EQ(4, ImageFormatSampleAlignment(image_format_bgra32.pixel_format));

  sysmem_v1::ImageFormat_2 image_format_nv12 = {
      .pixel_format.type = sysmem_v1::PixelFormatType::NV12,
      .coded_width = kWidth,
      .coded_height = kHeight,
      .bytes_per_row = kStride,
  };
  EXPECT_EQ(kHeight * kStride * 3 / 2, ImageFormatImageSize(image_format_nv12));
  EXPECT_EQ(2, ImageFormatCodedWidthMinDivisor(image_format_nv12.pixel_format));
  EXPECT_EQ(2, ImageFormatCodedHeightMinDivisor(image_format_nv12.pixel_format));
  EXPECT_EQ(2, ImageFormatSampleAlignment(image_format_nv12.pixel_format));
}

TEST(ImageFormat, BasicSizes_V1_C) {
  constexpr uint32_t kWidth = 64;
  constexpr uint32_t kHeight = 128;
  constexpr uint32_t kStride = 256;

  fuchsia_sysmem_ImageFormat_2 image_format_bgra32 = {
      .pixel_format.type = fuchsia_sysmem_PixelFormatType_BGRA32,
      .coded_width = kWidth,
      .coded_height = kHeight,
      .bytes_per_row = kStride,
  };
  EXPECT_EQ(kHeight * kStride, ImageFormatImageSize(&image_format_bgra32));
  EXPECT_EQ(1, ImageFormatCodedWidthMinDivisor(&image_format_bgra32.pixel_format));
  EXPECT_EQ(1, ImageFormatCodedHeightMinDivisor(&image_format_bgra32.pixel_format));
  EXPECT_EQ(4, ImageFormatSampleAlignment(&image_format_bgra32.pixel_format));

  fuchsia_sysmem_ImageFormat_2 image_format_nv12{
      .pixel_format.type = fuchsia_sysmem_PixelFormatType_NV12,
      .coded_width = kWidth,
      .coded_height = kHeight,
      .bytes_per_row = kStride,
  };
  EXPECT_EQ(kHeight * kStride * 3 / 2, ImageFormatImageSize(&image_format_nv12));
  EXPECT_EQ(2, ImageFormatCodedWidthMinDivisor(&image_format_nv12.pixel_format));
  EXPECT_EQ(2, ImageFormatCodedHeightMinDivisor(&image_format_nv12.pixel_format));
  EXPECT_EQ(2, ImageFormatSampleAlignment(&image_format_nv12.pixel_format));
}

TEST(ImageFormat, AfbcFlagFormats_V1_LLCPP) {
  sysmem_v1::PixelFormat format = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV_TE,
  };

  EXPECT_FALSE(image_format::FormatCompatibleWithProtectedMemory(format));

  sysmem_v1::ImageFormatConstraints constraints = {
      .pixel_format = format,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .min_coded_height = 12,
      .max_coded_height = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 4 * 8,
  };

  auto optional_format = image_format::ConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(optional_format);

  sysmem_v1::PixelFormat tiled_format = {
      .type = sysmem_v1::PixelFormatType::BGRA32,
      .has_format_modifier = true,
      .format_modifier.value =
          sysmem_v1::FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV_TILED_HEADER,
  };

  constraints.pixel_format = tiled_format;

  optional_format = image_format::ConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(optional_format);
  auto& image_format = *optional_format;
  constexpr uint32_t kMinHeaderOffset = 4096u;
  constexpr uint32_t kMinWidth = 128;
  constexpr uint32_t kMinHeight = 128;
  EXPECT_EQ(kMinHeaderOffset + kMinWidth * kMinHeight * 4, ImageFormatImageSize(image_format));
}

TEST(ImageFormat, R8G8Formats_V1_LLCPP) {
  sysmem_v1::PixelFormat format = {
      .type = sysmem_v1::PixelFormatType::R8G8,
      .has_format_modifier = true,
      .format_modifier.value = sysmem_v1::FORMAT_MODIFIER_LINEAR,
  };

  sysmem_v1::ImageFormatConstraints constraints = {
      .pixel_format = format,
      .min_coded_width = 12,
      .max_coded_width = 100,
      .min_coded_height = 12,
      .max_coded_height = 100,
      .max_bytes_per_row = 100000,
      .bytes_per_row_divisor = 1,
  };

  auto optional_format = image_format::ConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(optional_format);
  EXPECT_EQ(18u * 2, optional_format->bytes_per_row);
  EXPECT_EQ(18u * 17u * 2, ImageFormatImageSize(*optional_format));

  constraints.pixel_format.type = sysmem_v1::PixelFormatType::R8;

  optional_format = image_format::ConstraintsToFormat(constraints, 18, 17);
  EXPECT_TRUE(optional_format);
  EXPECT_EQ(18u * 1, optional_format->bytes_per_row);
  EXPECT_EQ(18u * 17u * 1, ImageFormatImageSize(*optional_format));
}

TEST(ImageFormat, CorrectModifiers) {
  EXPECT_EQ(sysmem_v1::FORMAT_MODIFIER_ARM_AFBC_16X16_YUV_TILED_HEADER,
            sysmem_v2::FORMAT_MODIFIER_ARM_AFBC_16X16_YUV_TILED_HEADER);
  EXPECT_EQ(sysmem_v1::FORMAT_MODIFIER_ARM_AFBC_16X16_YUV_TILED_HEADER,
            sysmem_v1::FORMAT_MODIFIER_ARM_AFBC_16X16 | sysmem_v1::FORMAT_MODIFIER_ARM_YUV_BIT |
                sysmem_v1::FORMAT_MODIFIER_ARM_TILED_HEADER_BIT);
}