tests/gtest/avifanimationtest.cc - libavif - Git at Google

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

 #include <algorithm>
 #include <cstdint>
 #include <cstring>
 #include <vector>

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

 namespace avif {
 namespace {

 // Used to pass the data folder path to the GoogleTest suites.
 const char* data_path = nullptr;

 TEST(AvifDecodeTest, AnimatedImage) {
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
   }
   // Both files should give exactly the same result: the audio is ignored
   // in 'colors-animated-8bpc-audio.avif' but shouldn't prevent the file from
   // decoding.
   for (const char* file_name :
        {"colors-animated-8bpc.avif", "colors-animated-8bpc-audio.avif"}) {
     SCOPED_TRACE(file_name);
     DecoderPtr decoder(avifDecoderCreate());
     ASSERT_NE(decoder, nullptr);
     ASSERT_EQ(avifDecoderSetIOFile(
                   decoder.get(), (std::string(data_path) + file_name).c_str()),
               AVIF_RESULT_OK);
     ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK)
         << decoder->diag.error;
     ;
     EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
     EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
     EXPECT_EQ(decoder->imageCount, 5);
     EXPECT_EQ(decoder->repetitionCount, 0);
     for (int i = 0; i < 5; ++i) {
       EXPECT_EQ(avifDecoderIsKeyframe(decoder.get(), i), i == 0);
       EXPECT_EQ(avifDecoderNearestKeyframe(decoder.get(), i), 0);
     }
     for (int i = 0; i < 5; ++i) {
       EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
     }
   }
 }

 TEST(AvifDecodeTest, AnimatedImageWithSourceSetToPrimaryItem) {
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
   }
   const char* file_name = "colors-animated-8bpc.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(
       avifDecoderSetSource(decoder.get(), AVIF_DECODER_SOURCE_PRIMARY_ITEM),
       AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   // imageCount is expected to be 1 because we are using primary item as the
   // preferred source.
   EXPECT_EQ(decoder->imageCount, 1);
   EXPECT_EQ(decoder->repetitionCount, 0);
   // Get the first (and only) image.
   EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
   // Subsequent calls should not return AVIF_RESULT_OK since there is only one
   // image in the preferred source.
   EXPECT_NE(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
 }

 TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadata) {
   const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageCount, 5);
   EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
   EXPECT_EQ(decoder->image->exif.size, 1126);
   EXPECT_EQ(decoder->image->xmp.size, 3898);
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
   }
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
     EXPECT_NE(decoder->image->alphaPlane, nullptr);
     EXPECT_GT(decoder->image->alphaRowBytes, 0);
   }
   EXPECT_EQ(avifDecoderNextImage(decoder.get()),
             AVIF_RESULT_NO_IMAGES_REMAINING);
 }

 //------------------------------------------------------------------------------
 // The alpha track of colors-animated-8bpc-alpha-exif-xmp.avif holds a 20 byte
 // 'tref' box at offset 1586, with a single 'auxl' box naming track 1, directly
 // followed by a 44 byte 'edts' box. Section 8.3.3.2 of ISO/IEC 14496-12 gives
 // TrackReferenceTypeBox an array of track_IDs, and nothing limits a 'tref' to
 // one box of a given type. The cases below rewrite those 64 bytes in place and
 // pad with a 'free' box, so the file size and every absolute offset in the file
 // keep the values of the valid file.

 constexpr const char* kAlphaTrackFileName =
     "colors-animated-8bpc-alpha-exif-xmp.avif";
 constexpr size_t kTrefOffset = 1586;
 constexpr size_t kTrefSize = 20;
 constexpr size_t kTrefAndEdtsSize = 64;

 void WriteBE32(uint32_t value, uint8_t* bytes) {
   bytes[0] = static_cast<uint8_t>(value >> 24);
   bytes[1] = static_cast<uint8_t>(value >> 16);
   bytes[2] = static_cast<uint8_t>(value >> 8);
   bytes[3] = static_cast<uint8_t>(value);
 }

 void AppendTrackReferenceTypeBox(const char* type,
                                  const std::vector<uint32_t>& track_ids,
                                  std::vector<uint8_t>* bytes) {
   const size_t size = 8 + 4 * track_ids.size();
   const size_t offset = bytes->size();
   bytes->resize(offset + size);
   WriteBE32(static_cast<uint32_t>(size), bytes->data() + offset);
   std::memcpy(bytes->data() + offset + 4, type, 4);
   for (size_t i = 0; i < track_ids.size(); ++i) {
     WriteBE32(track_ids[i], bytes->data() + offset + 8 + 4 * i);
   }
 }

 // Overwrites the 'tref' and 'edts' boxes of the alpha track with |boxes| and
 // fills the rest of the 64 bytes with a 'free' box.
 void ReplaceTrefAndEdts(const std::vector<uint8_t>& boxes,
                         testutil::AvifRwData* encoded) {
   ASSERT_GE(encoded->size, kTrefOffset + kTrefAndEdtsSize);
   uint8_t* p = encoded->data + kTrefOffset;
   // Sanity check: the fixture is the file these tests were authored against.
   ASSERT_EQ(std::memcmp(p + 4, "tref", 4), 0);
   ASSERT_EQ(std::memcmp(p + kTrefSize + 4, "edts", 4), 0);
   ASSERT_LE(boxes.size() + 8, kTrefAndEdtsSize);
   std::copy(boxes.begin(), boxes.end(), p);
   uint8_t* free_box = p + boxes.size();
   const size_t free_size = kTrefAndEdtsSize - boxes.size();
   WriteBE32(static_cast<uint32_t>(free_size), free_box);
   std::memcpy(free_box + 4, "free", 4);
   std::memset(free_box + 8, 0, free_size - 8);
 }

 void ExpectAlphaTrackIsFound(const testutil::AvifRwData& encoded) {
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   ASSERT_EQ(avifDecoderSetIOMemory(decoder.get(), encoded.data, encoded.size),
             AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageCount, 5);
 }

 // Control for the two cases below. The alpha track keeps its single reference,
 // only its 'edts' box is replaced by a 'free' box. Dropping it leaves that
 // track's repetition count unknown, which the decoder takes from the color
 // track anyway, so the alpha track still has to be found.
 TEST(AvifDecodeTest, AlphaTrackWithoutEdts) {
   testutil::AvifRwData encoded =
       testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
   ASSERT_NE(encoded.size, size_t{0});
   std::vector<uint8_t> tref;
   AppendTrackReferenceTypeBox("auxl", {1}, &tref);
   std::vector<uint8_t> boxes;
   AppendTrackReferenceTypeBox("tref", {}, &boxes);
   WriteBE32(static_cast<uint32_t>(8 + tref.size()), boxes.data());
   boxes.insert(boxes.end(), tref.begin(), tref.end());
   ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
   ExpectAlphaTrackIsFound(encoded);
 }

 // The 'tref' box holds two 'auxl' boxes. Check that both are read.
 TEST(AvifDecodeTest, AlphaTrackWithTwoAuxlBoxes) {
   testutil::AvifRwData encoded =
       testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
   ASSERT_NE(encoded.size, size_t{0});
   std::vector<uint8_t> children;
   AppendTrackReferenceTypeBox("auxl", {1}, &children);
   AppendTrackReferenceTypeBox("auxl", {99}, &children);
   std::vector<uint8_t> boxes;
   AppendTrackReferenceTypeBox("tref", {}, &boxes);
   WriteBE32(static_cast<uint32_t>(8 + children.size()), boxes.data());
   boxes.insert(boxes.end(), children.begin(), children.end());
   ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
   ExpectAlphaTrackIsFound(encoded);
 }

 // One 'auxl' box names two tracks. Check that both are read.
 TEST(AvifDecodeTest, AlphaTrackWithTwoTrackIds) {
   testutil::AvifRwData encoded =
       testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
   ASSERT_NE(encoded.size, size_t{0});
   std::vector<uint8_t> children;
   AppendTrackReferenceTypeBox("auxl", {99, 1}, &children);
   std::vector<uint8_t> boxes;
   AppendTrackReferenceTypeBox("tref", {}, &boxes);
   WriteBE32(static_cast<uint32_t>(8 + children.size()), boxes.data());
   boxes.insert(boxes.end(), children.begin(), children.end());
   ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
   ExpectAlphaTrackIsFound(encoded);
 }

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

 TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadataIgnoreAlpha) {
   const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   decoder->imageContentToDecode &= ~AVIF_IMAGE_CONTENT_ALPHA;
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageCount, 5);
   EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
   EXPECT_EQ(decoder->image->exif.size, 1126);
   EXPECT_EQ(decoder->image->xmp.size, 3898);
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
   }
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
     EXPECT_EQ(decoder->image->alphaPlane, nullptr);
     EXPECT_EQ(decoder->image->alphaRowBytes, 0);
   }
   EXPECT_EQ(avifDecoderNextImage(decoder.get()),
             AVIF_RESULT_NO_IMAGES_REMAINING);
 }

 TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadataIgnoreAll) {
   const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   decoder->imageContentToDecode = AVIF_IMAGE_CONTENT_NONE;
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageCount, 5);
   EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
   EXPECT_EQ(decoder->image->exif.size, 1126);
   EXPECT_EQ(decoder->image->xmp.size, 3898);
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
   }
   EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_NO_CONTENT);
 }

 TEST(AvifDecodeTest, AnimatedImageWithDepthAndMetadata) {
   // Depth is not supported and should be ignored.
   const char* file_name = "colors-animated-8bpc-depth-exif-xmp.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   EXPECT_EQ(decoder->imageCount, 5);
   EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
   EXPECT_EQ(decoder->image->exif.size, 1126);
   EXPECT_EQ(decoder->image->xmp.size, 3898);
 }

 TEST(AvifDecodeTest,
      AnimatedImageWithDepthAndMetadataWithSourceSetToPrimaryItem) {
   if (!testutil::Av1DecoderAvailable()) {
     GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
   }
   // Depth is not supported and should be ignored.
   const char* file_name = "colors-animated-8bpc-depth-exif-xmp.avif";
   DecoderPtr decoder(avifDecoderCreate());
   ASSERT_NE(decoder, nullptr);
   ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
                                  (std::string(data_path) + file_name).c_str()),
             AVIF_RESULT_OK);
   ASSERT_EQ(
       avifDecoderSetSource(decoder.get(), AVIF_DECODER_SOURCE_PRIMARY_ITEM),
       AVIF_RESULT_OK);
   ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
   EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
   EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
   // imageCount is expected to be 1 because we are using primary item as the
   // preferred source.
   EXPECT_EQ(decoder->imageCount, 1);
   EXPECT_EQ(decoder->repetitionCount, 0);
   EXPECT_EQ(decoder->image->exif.size, 1126);
   EXPECT_EQ(decoder->image->xmp.size, 3898);
   // Get the first (and only) image.
   EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
   // Subsequent calls should not return AVIF_RESULT_OK since there is only one
   // image in the preferred source.
   EXPECT_NE(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
 }

 TEST(AvifDecodeTest, AnimatedImageWithoutTracksShouldFail) {
   testutil::AvifRwData avif =
       testutil::ReadFile(std::string(data_path) + "colors-animated-8bpc.avif");
   // Edit the file to replace 'trak' box with a 'free' box. This way the file
   // will not contain any 'trak' boxes.
   const uint8_t* kTrak = reinterpret_cast<const uint8_t*>("trak");
   uint8_t* trak_position =
       std::search(avif.data, avif.data + avif.size, kTrak, kTrak + 4);
   ASSERT_NE(trak_position, avif.data + avif.size);
   trak_position[0] = static_cast<uint8_t>('f');
   trak_position[1] = static_cast<uint8_t>('r');
   trak_position[2] = static_cast<uint8_t>('e');
   trak_position[3] = static_cast<uint8_t>('e');

   for (auto source :
        {AVIF_DECODER_SOURCE_PRIMARY_ITEM, AVIF_DECODER_SOURCE_TRACKS}) {
     DecoderPtr decoder(avifDecoderCreate());
     ASSERT_NE(decoder, nullptr);
     ASSERT_EQ(avifDecoderSetIOMemory(decoder.get(), avif.data, avif.size),
               AVIF_RESULT_OK);
     ASSERT_EQ(avifDecoderSetSource(decoder.get(), source), AVIF_RESULT_OK);
     ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_BMFF_PARSE_FAILED);
   }
 }

 }  // namespace
 }  // namespace avif

 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   if (argc != 2) {
     std::cerr << "There must be exactly one argument containing the path to "
                  "the test data folder"
               << std::endl;
     return 1;
   }
   avif::data_path = argv[1];
   return RUN_ALL_TESTS();
 }
	// Copyright 2023 Google LLC
	// SPDX-License-Identifier: BSD-2-Clause

	#include <algorithm>
	#include <cstdint>
	#include <cstring>
	#include <vector>

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

	namespace avif {
	namespace {

	// Used to pass the data folder path to the GoogleTest suites.
	const char* data_path = nullptr;

	TEST(AvifDecodeTest, AnimatedImage) {
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
	}
	// Both files should give exactly the same result: the audio is ignored
	// in 'colors-animated-8bpc-audio.avif' but shouldn't prevent the file from
	// decoding.
	for (const char* file_name :
	{"colors-animated-8bpc.avif", "colors-animated-8bpc-audio.avif"}) {
	SCOPED_TRACE(file_name);
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOFile(
	decoder.get(), (std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK)
	<< decoder->diag.error;
	;
	EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	EXPECT_EQ(decoder->repetitionCount, 0);
	for (int i = 0; i < 5; ++i) {
	EXPECT_EQ(avifDecoderIsKeyframe(decoder.get(), i), i == 0);
	EXPECT_EQ(avifDecoderNearestKeyframe(decoder.get(), i), 0);
	}
	for (int i = 0; i < 5; ++i) {
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	}
	}
	}

	TEST(AvifDecodeTest, AnimatedImageWithSourceSetToPrimaryItem) {
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
	}
	const char* file_name = "colors-animated-8bpc.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(
	avifDecoderSetSource(decoder.get(), AVIF_DECODER_SOURCE_PRIMARY_ITEM),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	// imageCount is expected to be 1 because we are using primary item as the
	// preferred source.
	EXPECT_EQ(decoder->imageCount, 1);
	EXPECT_EQ(decoder->repetitionCount, 0);
	// Get the first (and only) image.
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	// Subsequent calls should not return AVIF_RESULT_OK since there is only one
	// image in the preferred source.
	EXPECT_NE(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	}

	TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadata) {
	const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
	EXPECT_EQ(decoder->image->exif.size, 1126);
	EXPECT_EQ(decoder->image->xmp.size, 3898);
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
	}
	for (int i = 0; i < 5; ++i) {
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	EXPECT_NE(decoder->image->alphaPlane, nullptr);
	EXPECT_GT(decoder->image->alphaRowBytes, 0);
	}
	EXPECT_EQ(avifDecoderNextImage(decoder.get()),
	AVIF_RESULT_NO_IMAGES_REMAINING);
	}

	//------------------------------------------------------------------------------
	// The alpha track of colors-animated-8bpc-alpha-exif-xmp.avif holds a 20 byte
	// 'tref' box at offset 1586, with a single 'auxl' box naming track 1, directly
	// followed by a 44 byte 'edts' box. Section 8.3.3.2 of ISO/IEC 14496-12 gives
	// TrackReferenceTypeBox an array of track_IDs, and nothing limits a 'tref' to
	// one box of a given type. The cases below rewrite those 64 bytes in place and
	// pad with a 'free' box, so the file size and every absolute offset in the file
	// keep the values of the valid file.

	constexpr const char* kAlphaTrackFileName =
	"colors-animated-8bpc-alpha-exif-xmp.avif";
	constexpr size_t kTrefOffset = 1586;
	constexpr size_t kTrefSize = 20;
	constexpr size_t kTrefAndEdtsSize = 64;

	void WriteBE32(uint32_t value, uint8_t* bytes) {
	bytes[0] = static_cast<uint8_t>(value >> 24);
	bytes[1] = static_cast<uint8_t>(value >> 16);
	bytes[2] = static_cast<uint8_t>(value >> 8);
	bytes[3] = static_cast<uint8_t>(value);
	}

	void AppendTrackReferenceTypeBox(const char* type,
	const std::vector<uint32_t>& track_ids,
	std::vector<uint8_t>* bytes) {
	const size_t size = 8 + 4 * track_ids.size();
	const size_t offset = bytes->size();
	bytes->resize(offset + size);
	WriteBE32(static_cast<uint32_t>(size), bytes->data() + offset);
	std::memcpy(bytes->data() + offset + 4, type, 4);
	for (size_t i = 0; i < track_ids.size(); ++i) {
	WriteBE32(track_ids[i], bytes->data() + offset + 8 + 4 * i);
	}
	}

	// Overwrites the 'tref' and 'edts' boxes of the alpha track with \|boxes\| and
	// fills the rest of the 64 bytes with a 'free' box.
	void ReplaceTrefAndEdts(const std::vector<uint8_t>& boxes,
	testutil::AvifRwData* encoded) {
	ASSERT_GE(encoded->size, kTrefOffset + kTrefAndEdtsSize);
	uint8_t* p = encoded->data + kTrefOffset;
	// Sanity check: the fixture is the file these tests were authored against.
	ASSERT_EQ(std::memcmp(p + 4, "tref", 4), 0);
	ASSERT_EQ(std::memcmp(p + kTrefSize + 4, "edts", 4), 0);
	ASSERT_LE(boxes.size() + 8, kTrefAndEdtsSize);
	std::copy(boxes.begin(), boxes.end(), p);
	uint8_t* free_box = p + boxes.size();
	const size_t free_size = kTrefAndEdtsSize - boxes.size();
	WriteBE32(static_cast<uint32_t>(free_size), free_box);
	std::memcpy(free_box + 4, "free", 4);
	std::memset(free_box + 8, 0, free_size - 8);
	}

	void ExpectAlphaTrackIsFound(const testutil::AvifRwData& encoded) {
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOMemory(decoder.get(), encoded.data, encoded.size),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	}

	// Control for the two cases below. The alpha track keeps its single reference,
	// only its 'edts' box is replaced by a 'free' box. Dropping it leaves that
	// track's repetition count unknown, which the decoder takes from the color
	// track anyway, so the alpha track still has to be found.
	TEST(AvifDecodeTest, AlphaTrackWithoutEdts) {
	testutil::AvifRwData encoded =
	testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
	ASSERT_NE(encoded.size, size_t{0});
	std::vector<uint8_t> tref;
	AppendTrackReferenceTypeBox("auxl", {1}, &tref);
	std::vector<uint8_t> boxes;
	AppendTrackReferenceTypeBox("tref", {}, &boxes);
	WriteBE32(static_cast<uint32_t>(8 + tref.size()), boxes.data());
	boxes.insert(boxes.end(), tref.begin(), tref.end());
	ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
	ExpectAlphaTrackIsFound(encoded);
	}

	// The 'tref' box holds two 'auxl' boxes. Check that both are read.
	TEST(AvifDecodeTest, AlphaTrackWithTwoAuxlBoxes) {
	testutil::AvifRwData encoded =
	testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
	ASSERT_NE(encoded.size, size_t{0});
	std::vector<uint8_t> children;
	AppendTrackReferenceTypeBox("auxl", {1}, &children);
	AppendTrackReferenceTypeBox("auxl", {99}, &children);
	std::vector<uint8_t> boxes;
	AppendTrackReferenceTypeBox("tref", {}, &boxes);
	WriteBE32(static_cast<uint32_t>(8 + children.size()), boxes.data());
	boxes.insert(boxes.end(), children.begin(), children.end());
	ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
	ExpectAlphaTrackIsFound(encoded);
	}

	// One 'auxl' box names two tracks. Check that both are read.
	TEST(AvifDecodeTest, AlphaTrackWithTwoTrackIds) {
	testutil::AvifRwData encoded =
	testutil::ReadFile(std::string(data_path) + kAlphaTrackFileName);
	ASSERT_NE(encoded.size, size_t{0});
	std::vector<uint8_t> children;
	AppendTrackReferenceTypeBox("auxl", {99, 1}, &children);
	std::vector<uint8_t> boxes;
	AppendTrackReferenceTypeBox("tref", {}, &boxes);
	WriteBE32(static_cast<uint32_t>(8 + children.size()), boxes.data());
	boxes.insert(boxes.end(), children.begin(), children.end());
	ASSERT_NO_FATAL_FAILURE(ReplaceTrefAndEdts(boxes, &encoded));
	ExpectAlphaTrackIsFound(encoded);
	}

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

	TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadataIgnoreAlpha) {
	const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	decoder->imageContentToDecode &= ~AVIF_IMAGE_CONTENT_ALPHA;
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
	EXPECT_EQ(decoder->image->exif.size, 1126);
	EXPECT_EQ(decoder->image->xmp.size, 3898);
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
	}
	for (int i = 0; i < 5; ++i) {
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->image->alphaPlane, nullptr);
	EXPECT_EQ(decoder->image->alphaRowBytes, 0);
	}
	EXPECT_EQ(avifDecoderNextImage(decoder.get()),
	AVIF_RESULT_NO_IMAGES_REMAINING);
	}

	TEST(AvifDecodeTest, AnimatedImageWithAlphaAndMetadataIgnoreAll) {
	const char* file_name = "colors-animated-8bpc-alpha-exif-xmp.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	decoder->imageContentToDecode = AVIF_IMAGE_CONTENT_NONE;
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
	EXPECT_EQ(decoder->image->exif.size, 1126);
	EXPECT_EQ(decoder->image->xmp.size, 3898);
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip the rest of the test.";
	}
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_NO_CONTENT);
	}

	TEST(AvifDecodeTest, AnimatedImageWithDepthAndMetadata) {
	// Depth is not supported and should be ignored.
	const char* file_name = "colors-animated-8bpc-depth-exif-xmp.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	EXPECT_EQ(decoder->imageCount, 5);
	EXPECT_EQ(decoder->repetitionCount, AVIF_REPETITION_COUNT_INFINITE);
	EXPECT_EQ(decoder->image->exif.size, 1126);
	EXPECT_EQ(decoder->image->xmp.size, 3898);
	}

	TEST(AvifDecodeTest,
	AnimatedImageWithDepthAndMetadataWithSourceSetToPrimaryItem) {
	if (!testutil::Av1DecoderAvailable()) {
	GTEST_SKIP() << "AV1 Codec unavailable, skip test.";
	}
	// Depth is not supported and should be ignored.
	const char* file_name = "colors-animated-8bpc-depth-exif-xmp.avif";
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOFile(decoder.get(),
	(std::string(data_path) + file_name).c_str()),
	AVIF_RESULT_OK);
	ASSERT_EQ(
	avifDecoderSetSource(decoder.get(), AVIF_DECODER_SOURCE_PRIMARY_ITEM),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_OK);
	EXPECT_EQ(decoder->alphaPresent, AVIF_FALSE);
	EXPECT_EQ(decoder->imageSequenceTrackPresent, AVIF_TRUE);
	// imageCount is expected to be 1 because we are using primary item as the
	// preferred source.
	EXPECT_EQ(decoder->imageCount, 1);
	EXPECT_EQ(decoder->repetitionCount, 0);
	EXPECT_EQ(decoder->image->exif.size, 1126);
	EXPECT_EQ(decoder->image->xmp.size, 3898);
	// Get the first (and only) image.
	EXPECT_EQ(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	// Subsequent calls should not return AVIF_RESULT_OK since there is only one
	// image in the preferred source.
	EXPECT_NE(avifDecoderNextImage(decoder.get()), AVIF_RESULT_OK);
	}

	TEST(AvifDecodeTest, AnimatedImageWithoutTracksShouldFail) {
	testutil::AvifRwData avif =
	testutil::ReadFile(std::string(data_path) + "colors-animated-8bpc.avif");
	// Edit the file to replace 'trak' box with a 'free' box. This way the file
	// will not contain any 'trak' boxes.
	const uint8_t* kTrak = reinterpret_cast<const uint8_t*>("trak");
	uint8_t* trak_position =
	std::search(avif.data, avif.data + avif.size, kTrak, kTrak + 4);
	ASSERT_NE(trak_position, avif.data + avif.size);
	trak_position[0] = static_cast<uint8_t>('f');
	trak_position[1] = static_cast<uint8_t>('r');
	trak_position[2] = static_cast<uint8_t>('e');
	trak_position[3] = static_cast<uint8_t>('e');

	for (auto source :
	{AVIF_DECODER_SOURCE_PRIMARY_ITEM, AVIF_DECODER_SOURCE_TRACKS}) {
	DecoderPtr decoder(avifDecoderCreate());
	ASSERT_NE(decoder, nullptr);
	ASSERT_EQ(avifDecoderSetIOMemory(decoder.get(), avif.data, avif.size),
	AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderSetSource(decoder.get(), source), AVIF_RESULT_OK);
	ASSERT_EQ(avifDecoderParse(decoder.get()), AVIF_RESULT_BMFF_PARSE_FAILED);
	}
	}

	} // namespace
	} // namespace avif

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	if (argc != 2) {
	std::cerr << "There must be exactly one argument containing the path to "
	"the test data folder"
	<< std::endl;
	return 1;
	}
	avif::data_path = argv[1];
	return RUN_ALL_TESTS();
	}