tests/gtest/avifgridapitest.cc

// Copyright 2022 Google LLC
// SPDX-License-Identifier: BSD-2-Clause

#include <cstring>
#include <vector>

#include "avif/avif.h"
#include "avif/internal.h"
#include "aviftest_helpers.h"
#include "gtest/gtest.h"

namespace avif {
namespace {

// Returns the content of the first box of the given type among the sibling
// boxes contained in container_content, or an empty avifROData if not found.
avifROData FindBox(avifROData container_content, const char type[4]) {
  avifROStream stream;
  avifROStreamStart(&stream, &container_content,
                    /*diag=*/nullptr, /*diagContext=*/nullptr);
  avifBoxHeader header;
  while (avifROStreamReadBoxHeader(&stream, &header)) {
    if (!memcmp(header.type, type, 4)) {
      return {avifROStreamCurrent(&stream), header.size};
    }
    if (!avifROStreamSkip(&stream, header.size)) {
      break;
    }
  }
  return {nullptr, 0};
}

// One AVIF cell in an AVIF grid.
struct Cell {
  int width, height;  // In pixels.
};

avifResult EncodeDecodeGrid(const std::vector<std::vector<Cell>>& cell_rows,
                            avifPixelFormat yuv_format) {
  // Construct a grid.
  std::vector<ImagePtr> cell_images;
  cell_images.reserve(cell_rows.size() * cell_rows.front().size());
  for (const std::vector<Cell>& cell_row : cell_rows) {
    assert(cell_row.size() == cell_rows.front().size());
    for (const Cell& cell : cell_row) {
      cell_images.emplace_back(testutil::CreateImage(
          cell.width, cell.height, /*depth=*/8, yuv_format, AVIF_PLANES_ALL));
      if (!cell_images.back()) {
        return AVIF_RESULT_INVALID_ARGUMENT;
      }
      testutil::FillImageGradient(cell_images.back().get());
    }
  }

  // Encode the grid image (losslessly for easy pixel-by-pixel comparison).
  EncoderPtr encoder(avifEncoderCreate());
  if (!encoder) {
    return AVIF_RESULT_OUT_OF_MEMORY;
  }
  encoder->speed = AVIF_SPEED_FASTEST;
  encoder->quality = AVIF_QUALITY_LOSSLESS;
  encoder->qualityAlpha = AVIF_QUALITY_LOSSLESS;
  // cell_image_ptrs exists only to match the libavif API.
  std::vector<avifImage*> cell_image_ptrs(cell_images.size());
  for (size_t i = 0; i < cell_images.size(); ++i) {
    cell_image_ptrs[i] = cell_images[i].get();
  }
  avifResult result = avifEncoderAddImageGrid(
      encoder.get(), static_cast<uint32_t>(cell_rows.front().size()),
      static_cast<uint32_t>(cell_rows.size()), cell_image_ptrs.data(),
      AVIF_ADD_IMAGE_FLAG_SINGLE);
  if (result != AVIF_RESULT_OK) {
    return result;
  }

  testutil::AvifRwData encoded_avif;
  result = avifEncoderFinish(encoder.get(), &encoded_avif);
  if (result != AVIF_RESULT_OK) {
    return result;
  }

  // Decode the grid image.
  ImagePtr image(avifImageCreateEmpty());
  DecoderPtr decoder(avifDecoderCreate());
  if (!image || !decoder) {
    return AVIF_RESULT_OUT_OF_MEMORY;
  }
  result = avifDecoderReadMemory(decoder.get(), image.get(), encoded_avif.data,
                                 encoded_avif.size);
  if (result != AVIF_RESULT_OK) {
    return result;
  }

  // Reconstruct the input image by merging all cells into a single avifImage.
  ImagePtr grid = testutil::CreateImage(
      static_cast<int>(image->width), static_cast<int>(image->height),
      /*depth=*/8, yuv_format, AVIF_PLANES_ALL);
  const int num_rows = (int)cell_rows.size();
  const int num_cols = (int)cell_rows[0].size();
  AVIF_CHECKRES(
      testutil::MergeGrid(num_cols, num_rows, cell_images, grid.get()));

  if ((grid->width != image->width) || (grid->height != image->height) ||
      !testutil::AreImagesEqual(*image, *grid)) {
    return AVIF_RESULT_UNKNOWN_ERROR;
  }

  return AVIF_RESULT_OK;
}

TEST(GridApiTest, SingleCell) {
  for (avifPixelFormat pixel_format :
       {AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
        AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
    // Rules on grids do not apply to a single cell.
    EXPECT_EQ(EncodeDecodeGrid({{{1, 1}}}, pixel_format), AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{1, 64}}}, pixel_format), AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{64, 1}}}, pixel_format), AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{64, 64}}}, pixel_format), AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{127, 127}}}, pixel_format), AVIF_RESULT_OK);
  }
}

TEST(GridApiTest, CellsOfSameDimensions) {
  for (avifPixelFormat pixel_format :
       {AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
        AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
    // ISO/IEC 23000-22:2019, Section 7.3.11.4.2:
    //   - the tile_width shall be greater than or equal to 64, and should be a
    //     multiple of 64
    //   - the tile_height shall be greater than or equal to 64, and should be a
    //     multiple of 64
    EXPECT_EQ(EncodeDecodeGrid({{{64, 64}, {64, 64}, {64, 64}}}, pixel_format),
              AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{100, 110}},  //
                                {{100, 110}},  //
                                {{100, 110}}},
                               pixel_format),
              AVIF_RESULT_OK);
    EXPECT_EQ(EncodeDecodeGrid({{{64, 64}, {64, 64}, {64, 64}},
                                {{64, 64}, {64, 64}, {64, 64}},
                                {{64, 64}, {64, 64}, {64, 64}}},
                               pixel_format),
              AVIF_RESULT_OK);

    EXPECT_EQ(EncodeDecodeGrid({{{2, 64}, {2, 64}}}, pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    EXPECT_EQ(EncodeDecodeGrid({{{64, 62}, {64, 62}}}, pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    EXPECT_EQ(EncodeDecodeGrid({{{64, 2}},  //
                                {{64, 2}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    EXPECT_EQ(EncodeDecodeGrid({{{2, 64}},  //
                                {{2, 64}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
  }

  // ISO/IEC 23000-22:2019, Section 7.3.11.4.2:
  //   - when the images are in the 4:2:2 chroma sampling format the horizontal
  //     tile offsets and widths, and the output width, shall be even numbers;
  EXPECT_EQ(EncodeDecodeGrid({{{64, 65}, {64, 65}}}, AVIF_PIXEL_FORMAT_YUV422),
            AVIF_RESULT_OK);
  EXPECT_EQ(EncodeDecodeGrid({{{65, 64}, {65, 64}}}, AVIF_PIXEL_FORMAT_YUV422),
            AVIF_RESULT_INVALID_IMAGE_GRID);
  //   - when the images are in the 4:2:0 chroma sampling format both the
  //     horizontal and vertical tile offsets and widths, and the output width
  //     and height, shall be even numbers.
  EXPECT_EQ(EncodeDecodeGrid({{{64, 65}, {64, 65}}}, AVIF_PIXEL_FORMAT_YUV420),
            AVIF_RESULT_INVALID_IMAGE_GRID);
  EXPECT_EQ(EncodeDecodeGrid({{{65, 64}, {65, 64}}}, AVIF_PIXEL_FORMAT_YUV420),
            AVIF_RESULT_INVALID_IMAGE_GRID);
}

TEST(GridApiTest, CellsOfDifferentDimensions) {
  for (avifPixelFormat pixel_format :
       {AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422,
        AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}) {
    // Right-most cells are narrower.
    EXPECT_EQ(
        EncodeDecodeGrid({{{100, 100}, {100, 100}, {66, 100}}}, pixel_format),
        AVIF_RESULT_OK);
    // Bottom-most cells are shorter.
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}},
                                {{100, 100}, {100, 100}},
                                {{100, 66}, {100, 66}}},
                               pixel_format),
              AVIF_RESULT_OK);
    // Right-most cells are narrower and bottom-most cells are shorter.
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}, {66, 100}},
                                {{100, 100}, {100, 100}, {66, 100}},
                                {{100, 66}, {100, 66}, {66, 66}}},
                               pixel_format),
              AVIF_RESULT_OK);

    // Right-most cells are wider.
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}, {222, 100}},
                                {{100, 100}, {100, 100}, {222, 100}},
                                {{100, 100}, {100, 100}, {222, 100}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    // Bottom-most cells are taller.
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}, {100, 100}},
                                {{100, 100}, {100, 100}, {100, 100}},
                                {{100, 222}, {100, 222}, {100, 222}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    // One cell dimension is off.
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}, {100, 100}},
                                {{100, 100}, {66 /* here */, 100}, {100, 100}},
                                {{100, 100}, {100, 100}, {100, 100}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
    EXPECT_EQ(EncodeDecodeGrid({{{100, 100}, {100, 100}, {66, 100}},
                                {{100, 100}, {100, 100}, {66, 100}},
                                {{100, 66}, {100, 66}, {66, 100 /* here */}}},
                               pixel_format),
              AVIF_RESULT_INVALID_IMAGE_GRID);
  }

  // ISO/IEC 23000-22:2019, Section 7.3.11.4.2:
  //   - when the images are in the 4:2:2 chroma sampling format the horizontal
  //     tile offsets and widths, and the output width, shall be even numbers;
  EXPECT_EQ(EncodeDecodeGrid({{{66, 66}},  //
                              {{66, 65}}},
                             AVIF_PIXEL_FORMAT_YUV422),
            AVIF_RESULT_OK);
  EXPECT_EQ(EncodeDecodeGrid({{{66, 66}, {65, 66}}}, AVIF_PIXEL_FORMAT_YUV422),
            AVIF_RESULT_INVALID_IMAGE_GRID);
  //   - when the images are in the 4:2:0 chroma sampling format both the
  //     horizontal and vertical tile offsets and widths, and the output width
  //     and height, shall be even numbers.
  EXPECT_EQ(EncodeDecodeGrid({{{66, 66}},  //
                              {{66, 65}}},
                             AVIF_PIXEL_FORMAT_YUV420),
            AVIF_RESULT_INVALID_IMAGE_GRID);
  EXPECT_EQ(EncodeDecodeGrid({{{66, 66}, {65, 66}}}, AVIF_PIXEL_FORMAT_YUV420),
            AVIF_RESULT_INVALID_IMAGE_GRID);
}

//------------------------------------------------------------------------------

TEST(GridApiTest, ColorAlphaGridExceeding16BitItemIDs) {
  // A color grid and an alpha grid of 128x256 cells each contain 32768 cells,
  // so encoding them requires 65538 distinct item IDs (2 grid items + 2 x 32768
  // cell items), which does not fit in the 16-bit item ID space (item ID 0 is
  // also invalid, see ISO/IEC 14496-12 Section 8.11.1.1). The encoder writes
  // the 32-bit item ID variants of the boxes with item ID fields
  // ('pitm' version 1, 'iloc' version 2, 'iinf' version 1, 'infe' version 3,
  // 'iref' version 1 and 'ipma' version 1) so that such files are valid.
  // The cells are 64x64 because it is the smallest size allowed by MIAF.
  // Note: Most of the time spent in this test is the encoding of the 65536
  // cells. The generated file is not parsed with avifDecoderParse() because
  // that would cost minutes with the current quadratic lookups for this many
  // items; walking the boxes below is enough to check what was written.
  ImagePtr cell = testutil::CreateImage(
      /*width=*/64, /*height=*/64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV400,
      AVIF_PLANES_ALL /* the alpha channel is needed */);
  ASSERT_NE(cell, nullptr);
  // The pixels do not matter but avoid use-of-uninitialized-value errors.
  testutil::FillImageGradient(cell.get());
  const std::vector<avifImage*> cell_image_ptrs(128 * 256, cell.get());

  EncoderPtr encoder(avifEncoderCreate());
  ASSERT_NE(encoder, nullptr);
  // Worst quality to keep the encoding of the 65536 cells as fast as possible.
  encoder->speed = AVIF_SPEED_FASTEST;
  encoder->quality = AVIF_QUALITY_WORST;
  ASSERT_EQ(avifEncoderAddImageGrid(encoder.get(), /*gridCols=*/128,
                                    /*gridRows=*/256, cell_image_ptrs.data(),
                                    AVIF_ADD_IMAGE_FLAG_SINGLE),
            AVIF_RESULT_OK);
  testutil::AvifRwData encoded_avif;
  ASSERT_EQ(avifEncoderFinish(encoder.get(), &encoded_avif), AVIF_RESULT_OK);

  // The color grid item, the color cell items, the alpha grid item, the alpha
  // cell items and possibly some metadata items are given sequential item IDs,
  // starting with the primary item (the color grid item).
  constexpr uint32_t kExpectedItemCount = 65538;

  const avifROData file = {encoded_avif.data, encoded_avif.size};
  avifROData meta = FindBox(file, "meta");
  ASSERT_NE(meta.data, nullptr);
  // The 'meta' box is a FullBox: its version and flags come before its child
  // boxes.
  const avifROData meta_children = {meta.data + 4, meta.size - 4};

  // 'pitm' version 1 and a 32-bit primary item ID.
  avifROData pitm = FindBox(meta_children, "pitm");
  ASSERT_NE(pitm.data, nullptr);
  {
    avifROStream stream;
    avifROStreamStart(&stream, &pitm, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint8_t version;
    uint32_t flags;
    ASSERT_TRUE(avifROStreamReadVersionAndFlags(&stream, &version, &flags));
    EXPECT_EQ(version, 1);
    uint32_t item_id;
    ASSERT_TRUE(avifROStreamReadU32(&stream, &item_id));
    EXPECT_EQ(item_id, 1);
  }

  // 'iloc' version 2 and a 32-bit item_count.
  avifROData iloc = FindBox(meta_children, "iloc");
  ASSERT_NE(iloc.data, nullptr);
  {
    avifROStream stream;
    avifROStreamStart(&stream, &iloc, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint8_t version;
    ASSERT_TRUE(avifROStreamReadVersionAndFlags(&stream, &version, nullptr));
    EXPECT_EQ(version, 2);
    ASSERT_TRUE(avifROStreamSkip(
        &stream,
        2));  // offset_size, length_size, base_offset_size and index_size
    uint32_t item_count;
    ASSERT_TRUE(avifROStreamReadU32(&stream, &item_count));
    EXPECT_EQ(item_count, kExpectedItemCount);
  }

  // 'iinf' version 1, a 32-bit entry_count, and 'infe' entries with version 3.
  avifROData iinf = FindBox(meta_children, "iinf");
  ASSERT_NE(iinf.data, nullptr);
  {
    avifROStream stream;
    avifROStreamStart(&stream, &iinf, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint8_t version;
    ASSERT_TRUE(avifROStreamReadVersionAndFlags(&stream, &version, nullptr));
    EXPECT_EQ(version, 1);
    uint32_t entry_count;
    ASSERT_TRUE(avifROStreamReadU32(&stream, &entry_count));
    EXPECT_EQ(entry_count, kExpectedItemCount);
    // The 'infe' child boxes follow the version, flags and entry_count fields.
    avifROData iinf_children = {iinf.data + 8, iinf.size - 8};
    avifROData infe = FindBox(iinf_children, "infe");
    ASSERT_NE(infe.data, nullptr);
    avifROStream infe_stream;
    avifROStreamStart(&infe_stream, &infe, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    ASSERT_TRUE(
        avifROStreamReadVersionAndFlags(&infe_stream, &version, nullptr));
    EXPECT_EQ(version, 3);
    uint32_t item_id;
    ASSERT_TRUE(avifROStreamReadU32(&infe_stream, &item_id));
    EXPECT_EQ(item_id, 1);
  }

  // 'iref' version 1 and 32-bit item_ID fields in the 'dimg' references.
  avifROData iref = FindBox(meta_children, "iref");
  ASSERT_NE(iref.data, nullptr);
  {
    avifROStream stream;
    avifROStreamStart(&stream, &iref, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint8_t version;
    ASSERT_TRUE(avifROStreamReadVersionAndFlags(&stream, &version, nullptr));
    EXPECT_EQ(version, 1);
    // The SingleItemTypeReferenceBox child boxes follow the version and flags.
    avifROData iref_children = {iref.data + 4, iref.size - 4};
    avifROData dimg = FindBox(iref_children, "dimg");
    ASSERT_NE(dimg.data, nullptr);
    avifROStream dimg_stream;
    avifROStreamStart(&dimg_stream, &dimg, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint32_t from_item_id;
    ASSERT_TRUE(avifROStreamReadU32(&dimg_stream, &from_item_id));
    EXPECT_EQ(from_item_id, 1);
    uint16_t reference_count;
    ASSERT_TRUE(avifROStreamReadU16(&dimg_stream, &reference_count));
    EXPECT_EQ(reference_count, 32768);
  }

  // 'ipma' version 1 and a 32-bit item_ID field per entry.
  const avifROData iprp = FindBox(meta_children, "iprp");
  ASSERT_NE(iprp.data, nullptr);
  avifROData ipma = FindBox(iprp, "ipma");
  ASSERT_NE(ipma.data, nullptr);
  {
    avifROStream stream;
    avifROStreamStart(&stream, &ipma, /*diag=*/nullptr,
                      /*diagContext=*/nullptr);
    uint8_t version;
    uint32_t flags;
    ASSERT_TRUE(avifROStreamReadVersionAndFlags(&stream, &version, &flags));
    EXPECT_EQ(version, 1);
    EXPECT_EQ(flags, 0);  // The property_index fields are 7-bit wide.
    uint32_t entry_count;
    ASSERT_TRUE(avifROStreamReadU32(&stream, &entry_count));
    EXPECT_EQ(entry_count, kExpectedItemCount);
    uint32_t item_id;
    ASSERT_TRUE(avifROStreamReadU32(&stream, &item_id));
    EXPECT_EQ(item_id, 1);
  }
}

TEST(GridApiTest, CellCountExceeding16BitReferenceCount) {
  // A 256x256 grid contains 65536 cells, which does not fit in the 16-bit
  // reference_count field of a 'dimg' item reference (ISO/IEC 14496-12
  // Section 8.11.12), so avifEncoderAddImageGrid() refuses it. Note that the
  // maximum is a single 256x256 grid; any other combination of grid
  // dimensions is at most 256x255 = 65280 cells.
  ImagePtr cell = testutil::CreateImage(
      /*width=*/64, /*height=*/64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV400,
      AVIF_PLANES_ALL);
  ASSERT_NE(cell, nullptr);
  const std::vector<avifImage*> cell_image_ptrs(256 * 256, cell.get());

  EncoderPtr encoder(avifEncoderCreate());
  ASSERT_NE(encoder, nullptr);
  ASSERT_EQ(avifEncoderAddImageGrid(encoder.get(), /*gridCols=*/256,
                                    /*gridRows=*/256, cell_image_ptrs.data(),
                                    AVIF_ADD_IMAGE_FLAG_SINGLE),
            AVIF_RESULT_INVALID_IMAGE_GRID);
}

//------------------------------------------------------------------------------

TEST(GridApiTest, SameMatrixCoefficients) {
  ImagePtr cell_0 = testutil::CreateImage(
      64, 64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444, AVIF_PLANES_ALL);
  ImagePtr cell_1 = testutil::CreateImage(
      1, 64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444, AVIF_PLANES_ALL);
  ASSERT_NE(cell_0, nullptr);
  ASSERT_NE(cell_1, nullptr);

  // The pixels do not matter but avoid use-of-uninitialized-value errors.
  testutil::FillImageGradient(cell_0.get());
  testutil::FillImageGradient(cell_1.get());

  // All input cells have the same non-default properties.
  cell_0->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
  cell_1->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;

  EncoderPtr encoder(avifEncoderCreate());
  ASSERT_NE(encoder, nullptr);
  encoder->speed = AVIF_SPEED_FASTEST;
  const avifImage* cell_image_ptrs[2] = {cell_0.get(), cell_1.get()};
  ASSERT_EQ(
      avifEncoderAddImageGrid(encoder.get(), /*gridCols=*/2, /*gridRows=*/1,
                              cell_image_ptrs, AVIF_ADD_IMAGE_FLAG_SINGLE),
      AVIF_RESULT_OK);
  testutil::AvifRwData encoded_avif;
  ASSERT_EQ(avifEncoderFinish(encoder.get(), &encoded_avif), AVIF_RESULT_OK);
  ASSERT_NE(testutil::Decode(encoded_avif.data, encoded_avif.size), nullptr);
}

TEST(GridApiTest, DifferentMatrixCoefficients) {
  ImagePtr cell_0 = testutil::CreateImage(
      64, 64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444, AVIF_PLANES_ALL);
  ImagePtr cell_1 = testutil::CreateImage(
      1, 64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444, AVIF_PLANES_ALL);
  ASSERT_NE(cell_0, nullptr);
  ASSERT_NE(cell_1, nullptr);

  // The pixels do not matter but avoid use-of-uninitialized-value errors.
  testutil::FillImageGradient(cell_0.get());
  testutil::FillImageGradient(cell_1.get());

  // Some input cells have different properties.
  cell_0->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
  cell_1->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED;

  EncoderPtr encoder(avifEncoderCreate());
  ASSERT_NE(encoder, nullptr);
  encoder->speed = AVIF_SPEED_FASTEST;
  // Encoding should fail.
  const avifImage* cell_image_ptrs[2] = {cell_0.get(), cell_1.get()};
  ASSERT_EQ(
      avifEncoderAddImageGrid(encoder.get(), /*gridCols=*/2, /*gridRows=*/1,
                              cell_image_ptrs, AVIF_ADD_IMAGE_FLAG_SINGLE),
      AVIF_RESULT_INVALID_IMAGE_GRID);
}

TEST(GridApiTest, CellsTooManyForDimgReferenceCount) {
  // Section 8.11.12.1 of ISO/IEC 14496-12 requires all the references from one
  // item to be collected into a single item type reference box, whose
  // reference_count field is unsigned int(16) whatever the 'iref' version
  // (Section 8.11.12.2). ISO/IEC 23008-12 (HEIF) Section 6.6.1 additionally
  // forbids more than one 'dimg' box with the same from_item_ID. A grid item
  // therefore cannot have more than 65535 cells, so a 256x256-cell grid is
  // rejected upfront instead of silently generating a broken file.
  ImagePtr cell = testutil::CreateImage(
      /*width=*/64, /*height=*/64, /*depth=*/8, AVIF_PIXEL_FORMAT_YUV400,
      AVIF_PLANES_YUV);
  ASSERT_NE(cell, nullptr);
  testutil::FillImageGradient(cell.get());
  const std::vector<avifImage*> cell_image_ptrs(256 * 256, cell.get());

  EncoderPtr encoder(avifEncoderCreate());
  ASSERT_NE(encoder, nullptr);
  encoder->speed = AVIF_SPEED_FASTEST;
  ASSERT_EQ(avifEncoderAddImageGrid(encoder.get(), /*gridCols=*/256,
                                    /*gridRows=*/256, cell_image_ptrs.data(),
                                    AVIF_ADD_IMAGE_FLAG_SINGLE),
            AVIF_RESULT_INVALID_IMAGE_GRID);
}

}  // namespace
}  // namespace avif