test/film_grain_table_test.cc - aom - Git at Google

 /*
  * Copyright (c) 2018, Alliance for Open Media. All rights reserved
  *
  * This source code is subject to the terms of the BSD 2 Clause License and
  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
  * was not distributed with this source code in the LICENSE file, you can
  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
  * Media Patent License 1.0 was not distributed with this source code in the
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */

 #include <string>
 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
 #include "aom_dsp/grain_table.h"
 #include "aom/internal/aom_codec_internal.h"
 #include "av1/encoder/grain_test_vectors.h"
 #include "test/codec_factory.h"
 #include "test/encode_test_driver.h"
 #include "test/i420_video_source.h"
 #include "test/util.h"
 #include "test/video_source.h"

 void grain_equal(const aom_film_grain_t *expected,
                  const aom_film_grain_t *actual) {
   EXPECT_EQ(expected->apply_grain, actual->apply_grain);
   EXPECT_EQ(expected->update_parameters, actual->update_parameters);
   if (!expected->update_parameters) return;
   EXPECT_EQ(expected->num_y_points, actual->num_y_points);
   EXPECT_EQ(expected->num_cb_points, actual->num_cb_points);
   EXPECT_EQ(expected->num_cr_points, actual->num_cr_points);
   EXPECT_EQ(0, memcmp(expected->scaling_points_y, actual->scaling_points_y,
                       expected->num_y_points *
                           sizeof(expected->scaling_points_y[0])));
   EXPECT_EQ(0, memcmp(expected->scaling_points_cb, actual->scaling_points_cb,
                       expected->num_cb_points *
                           sizeof(expected->scaling_points_cb[0])));
   EXPECT_EQ(0, memcmp(expected->scaling_points_cr, actual->scaling_points_cr,
                       expected->num_cr_points *
                           sizeof(expected->scaling_points_cr[0])));
   EXPECT_EQ(expected->scaling_shift, actual->scaling_shift);
   EXPECT_EQ(expected->ar_coeff_lag, actual->ar_coeff_lag);
   EXPECT_EQ(expected->ar_coeff_shift, actual->ar_coeff_shift);

   const int num_pos_luma =
       2 * expected->ar_coeff_lag * (expected->ar_coeff_lag + 1);
   const int num_pos_chroma = num_pos_luma;
   EXPECT_EQ(0, memcmp(expected->ar_coeffs_y, actual->ar_coeffs_y,
                       sizeof(expected->ar_coeffs_y[0]) * num_pos_luma));
   if (actual->num_cb_points || actual->chroma_scaling_from_luma) {
     EXPECT_EQ(0, memcmp(expected->ar_coeffs_cb, actual->ar_coeffs_cb,
                         sizeof(expected->ar_coeffs_cb[0]) * num_pos_chroma));
   }
   if (actual->num_cr_points || actual->chroma_scaling_from_luma) {
     EXPECT_EQ(0, memcmp(expected->ar_coeffs_cr, actual->ar_coeffs_cr,
                         sizeof(expected->ar_coeffs_cr[0]) * num_pos_chroma));
   }
   EXPECT_EQ(expected->overlap_flag, actual->overlap_flag);
   EXPECT_EQ(expected->chroma_scaling_from_luma,
             actual->chroma_scaling_from_luma);
   EXPECT_EQ(expected->grain_scale_shift, actual->grain_scale_shift);
   // EXPECT_EQ(expected->random_seed, actual->random_seed);

   // clip_to_restricted and bit_depth aren't written
   if (expected->num_cb_points) {
     EXPECT_EQ(expected->cb_mult, actual->cb_mult);
     EXPECT_EQ(expected->cb_luma_mult, actual->cb_luma_mult);
     EXPECT_EQ(expected->cb_offset, actual->cb_offset);
   }
   if (expected->num_cr_points) {
     EXPECT_EQ(expected->cr_mult, actual->cr_mult);
     EXPECT_EQ(expected->cr_luma_mult, actual->cr_luma_mult);
     EXPECT_EQ(expected->cr_offset, actual->cr_offset);
   }
 }

 TEST(FilmGrainTableTest, AddAndLookupSingleSegment) {
   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));

   aom_film_grain_t grain;
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));

   aom_film_grain_table_append(&table, 1000, 2000, film_grain_test_vectors + 0);
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));

   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));

   grain.bit_depth = film_grain_test_vectors[0].bit_depth;
   EXPECT_EQ(0, memcmp(&grain, film_grain_test_vectors + 0, sizeof(table)));

   // Extend the existing segment
   aom_film_grain_table_append(&table, 2000, 3000, film_grain_test_vectors + 0);
   EXPECT_EQ(0, table.head->next);

   // Lookup and remove and check that the entry is no longer there
   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, true, &grain));
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));

   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, true, &grain));
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));

   EXPECT_EQ(0, table.head);
   EXPECT_EQ(0, table.tail);
   aom_film_grain_table_free(&table);
 }

 TEST(FilmGrainTableTest, AddSingleSegmentRemoveBiggerSegment) {
   aom_film_grain_table_t table;
   aom_film_grain_t grain;

   memset(&table, 0, sizeof(table));

   aom_film_grain_table_append(&table, 0, 1000, film_grain_test_vectors + 0);
   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 0, 1100, true, &grain));

   EXPECT_EQ(0, table.head);
   EXPECT_EQ(0, table.tail);
   aom_film_grain_table_free(&table);
 }

 TEST(FilmGrainTableTest, SplitSingleSegment) {
   aom_film_grain_table_t table;
   aom_film_grain_t grain;
   memset(&table, 0, sizeof(table));

   aom_film_grain_table_append(&table, 0, 1000, film_grain_test_vectors + 0);

   // Test lookup and remove that adjusts start time
   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 0, 100, true, &grain));
   EXPECT_EQ(nullptr, table.head->next);
   EXPECT_EQ(100, table.head->start_time);

   // Test lookup and remove that adjusts end time
   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 900, 1000, true, &grain));
   EXPECT_EQ(nullptr, table.head->next);
   EXPECT_EQ(100, table.head->start_time);
   EXPECT_EQ(900, table.head->end_time);

   // Test lookup and remove that splits the first entry
   EXPECT_TRUE(aom_film_grain_table_lookup(&table, 400, 600, true, &grain));
   EXPECT_EQ(100, table.head->start_time);
   EXPECT_EQ(400, table.head->end_time);

   ASSERT_NE(nullptr, table.head->next);
   EXPECT_EQ(table.tail, table.head->next);
   EXPECT_EQ(600, table.head->next->start_time);
   EXPECT_EQ(900, table.head->next->end_time);

   aom_film_grain_table_free(&table);
 }

 TEST(FilmGrainTableTest, AddAndLookupMultipleSegments) {
   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));

   aom_film_grain_t grain;
   const int kNumTestVectors =
       sizeof(film_grain_test_vectors) / sizeof(film_grain_test_vectors[0]);
   for (int i = 0; i < kNumTestVectors; ++i) {
     aom_film_grain_table_append(&table, i * 1000, (i + 1) * 1000,
                                 film_grain_test_vectors + i);
   }

   for (int i = kNumTestVectors - 1; i >= 0; --i) {
     EXPECT_TRUE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
                                             true, &grain));
     grain_equal(film_grain_test_vectors + i, &grain);
     EXPECT_FALSE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
                                              true, &grain));
   }

   // Verify that all the data has been removed
   for (int i = 0; i < kNumTestVectors; ++i) {
     EXPECT_FALSE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
                                              true, &grain));
   }
   aom_film_grain_table_free(&table);
 }

 class FilmGrainTableIOTest : public ::testing::Test {
  protected:
   void SetUp() { memset(&error_, 0, sizeof(error_)); }
   struct aom_internal_error_info error_;
 };

 TEST_F(FilmGrainTableIOTest, ReadMissingFile) {
   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));
   ASSERT_EQ(AOM_CODEC_ERROR, aom_film_grain_table_read(
                                  &table, "/path/to/missing/file", &error_));
 }

 TEST_F(FilmGrainTableIOTest, ReadTruncatedFile) {
   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));

   std::string grain_file;
   FILE *file = libaom_test::GetTempOutFile(&grain_file);
   ASSERT_NE(file, nullptr);
   fwrite("deadbeef", 8, 1, file);
   fclose(file);
   ASSERT_EQ(AOM_CODEC_ERROR,
             aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
   EXPECT_EQ(0, remove(grain_file.c_str()));
 }

 TEST_F(FilmGrainTableIOTest, RoundTripReadWrite) {
   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));

   aom_film_grain_t expected_grain[16];
   const int kNumTestVectors =
       sizeof(film_grain_test_vectors) / sizeof(film_grain_test_vectors[0]);
   for (int i = 0; i < kNumTestVectors; ++i) {
     expected_grain[i] = film_grain_test_vectors[i];
     expected_grain[i].random_seed = i;
     expected_grain[i].update_parameters = i % 2;
     expected_grain[i].apply_grain = (i + 1) % 2;
     expected_grain[i].bit_depth = 0;
     aom_film_grain_table_append(&table, i * 1000, (i + 1) * 1000,
                                 expected_grain + i);
   }
   std::string grain_file;
   FILE *tmpfile = libaom_test::GetTempOutFile(&grain_file);
   ASSERT_NE(tmpfile, nullptr);
   fclose(tmpfile);
   ASSERT_EQ(AOM_CODEC_OK,
             aom_film_grain_table_write(&table, grain_file.c_str(), &error_));
   aom_film_grain_table_free(&table);

   memset(&table, 0, sizeof(table));
   ASSERT_EQ(AOM_CODEC_OK,
             aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
   for (int i = 0; i < kNumTestVectors; ++i) {
     aom_film_grain_t grain;
     EXPECT_TRUE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
                                             true, &grain));
     grain_equal(expected_grain + i, &grain);
   }
   aom_film_grain_table_free(&table);
   EXPECT_EQ(0, remove(grain_file.c_str()));
 }

 TEST_F(FilmGrainTableIOTest, RoundTripSplit) {
   std::string grain_file;
   FILE *tmpfile = libaom_test::GetTempOutFile(&grain_file);
   ASSERT_NE(tmpfile, nullptr);
   fclose(tmpfile);

   aom_film_grain_table_t table;
   memset(&table, 0, sizeof(table));

   aom_film_grain_t grain = film_grain_test_vectors[0];
   aom_film_grain_table_append(&table, 0, 3000, &grain);
   ASSERT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, true, &grain));
   ASSERT_TRUE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
   EXPECT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));
   ASSERT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));
   ASSERT_EQ(AOM_CODEC_OK,
             aom_film_grain_table_write(&table, grain_file.c_str(), &error_));
   aom_film_grain_table_free(&table);

   memset(&table, 0, sizeof(table));
   ASSERT_EQ(AOM_CODEC_OK,
             aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
   ASSERT_TRUE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
   ASSERT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));
   ASSERT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));
   aom_film_grain_table_free(&table);

   EXPECT_EQ(0, remove(grain_file.c_str()));
 }

 const ::libaom_test::TestMode kFilmGrainEncodeTestModes[] = {
   ::libaom_test::kRealTime,
 #if !CONFIG_REALTIME_ONLY
   ::libaom_test::kOnePassGood
 #endif
 };

 class FilmGrainEncodeTest
     : public ::libaom_test::CodecTestWith2Params<bool, ::libaom_test::TestMode>,
       public ::libaom_test::EncoderTest {
  protected:
   FilmGrainEncodeTest()
       : EncoderTest(GET_PARAM(0)), test_monochrome_(GET_PARAM(1)),
         test_mode_(GET_PARAM(2)) {}
   ~FilmGrainEncodeTest() override = default;

   void SetUp() override {
     InitializeConfig(test_mode_);
     cfg_.monochrome = test_monochrome_;
     cfg_.rc_target_bitrate = 300;
     cfg_.kf_max_dist = 0;
   }

   void PreEncodeFrameHook(::libaom_test::VideoSource *video,
                           ::libaom_test::Encoder *encoder) override {
     if (video->frame() == 0) {
       encoder->Control(AOME_SET_CPUUSED, 5);
       encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_FILM);
       encoder->Control(AV1E_SET_DENOISE_NOISE_LEVEL, 1);
     } else if (video->frame() == 1) {
       cfg_.monochrome = 0;
       encoder->Config(&cfg_);
     } else {
       cfg_.monochrome = test_monochrome_;
       encoder->Config(&cfg_);
     }
   }

   bool DoDecode() const override { return false; }

   void DoTest() {
     if (test_monochrome_ && test_mode_ == ::libaom_test::kRealTime) {
       // TODO(bohanli): Running real time mode with monochrome will cause the
       // encoder to crash. Check if this is intended or there is a bug.
       GTEST_SKIP();
     }
     ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352,
                                          288, 30, 1, 0, 3);
     cfg_.g_w = video.img()->d_w;
     cfg_.g_h = video.img()->d_h;
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   }

  private:
   bool test_monochrome_;
   ::libaom_test::TestMode test_mode_;
 };

 TEST_P(FilmGrainEncodeTest, Test) { DoTest(); }

 AV1_INSTANTIATE_TEST_SUITE(FilmGrainEncodeTest, ::testing::Bool(),
                            ::testing::ValuesIn(kFilmGrainEncodeTestModes));
	/*
	* Copyright (c) 2018, Alliance for Open Media. All rights reserved
	*
	* This source code is subject to the terms of the BSD 2 Clause License and
	* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
	* was not distributed with this source code in the LICENSE file, you can
	* obtain it at www.aomedia.org/license/software. If the Alliance for Open
	* Media Patent License 1.0 was not distributed with this source code in the
	* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
	*/

	#include <string>
	#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
	#include "aom_dsp/grain_table.h"
	#include "aom/internal/aom_codec_internal.h"
	#include "av1/encoder/grain_test_vectors.h"
	#include "test/codec_factory.h"
	#include "test/encode_test_driver.h"
	#include "test/i420_video_source.h"
	#include "test/util.h"
	#include "test/video_source.h"

	void grain_equal(const aom_film_grain_t *expected,
	const aom_film_grain_t *actual) {
	EXPECT_EQ(expected->apply_grain, actual->apply_grain);
	EXPECT_EQ(expected->update_parameters, actual->update_parameters);
	if (!expected->update_parameters) return;
	EXPECT_EQ(expected->num_y_points, actual->num_y_points);
	EXPECT_EQ(expected->num_cb_points, actual->num_cb_points);
	EXPECT_EQ(expected->num_cr_points, actual->num_cr_points);
	EXPECT_EQ(0, memcmp(expected->scaling_points_y, actual->scaling_points_y,
	expected->num_y_points *
	sizeof(expected->scaling_points_y[0])));
	EXPECT_EQ(0, memcmp(expected->scaling_points_cb, actual->scaling_points_cb,
	expected->num_cb_points *
	sizeof(expected->scaling_points_cb[0])));
	EXPECT_EQ(0, memcmp(expected->scaling_points_cr, actual->scaling_points_cr,
	expected->num_cr_points *
	sizeof(expected->scaling_points_cr[0])));
	EXPECT_EQ(expected->scaling_shift, actual->scaling_shift);
	EXPECT_EQ(expected->ar_coeff_lag, actual->ar_coeff_lag);
	EXPECT_EQ(expected->ar_coeff_shift, actual->ar_coeff_shift);

	const int num_pos_luma =
	2 * expected->ar_coeff_lag * (expected->ar_coeff_lag + 1);
	const int num_pos_chroma = num_pos_luma;
	EXPECT_EQ(0, memcmp(expected->ar_coeffs_y, actual->ar_coeffs_y,
	sizeof(expected->ar_coeffs_y[0]) * num_pos_luma));
	if (actual->num_cb_points \|\| actual->chroma_scaling_from_luma) {
	EXPECT_EQ(0, memcmp(expected->ar_coeffs_cb, actual->ar_coeffs_cb,
	sizeof(expected->ar_coeffs_cb[0]) * num_pos_chroma));
	}
	if (actual->num_cr_points \|\| actual->chroma_scaling_from_luma) {
	EXPECT_EQ(0, memcmp(expected->ar_coeffs_cr, actual->ar_coeffs_cr,
	sizeof(expected->ar_coeffs_cr[0]) * num_pos_chroma));
	}
	EXPECT_EQ(expected->overlap_flag, actual->overlap_flag);
	EXPECT_EQ(expected->chroma_scaling_from_luma,
	actual->chroma_scaling_from_luma);
	EXPECT_EQ(expected->grain_scale_shift, actual->grain_scale_shift);
	// EXPECT_EQ(expected->random_seed, actual->random_seed);

	// clip_to_restricted and bit_depth aren't written
	if (expected->num_cb_points) {
	EXPECT_EQ(expected->cb_mult, actual->cb_mult);
	EXPECT_EQ(expected->cb_luma_mult, actual->cb_luma_mult);
	EXPECT_EQ(expected->cb_offset, actual->cb_offset);
	}
	if (expected->num_cr_points) {
	EXPECT_EQ(expected->cr_mult, actual->cr_mult);
	EXPECT_EQ(expected->cr_luma_mult, actual->cr_luma_mult);
	EXPECT_EQ(expected->cr_offset, actual->cr_offset);
	}
	}

	TEST(FilmGrainTableTest, AddAndLookupSingleSegment) {
	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));

	aom_film_grain_t grain;
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));

	aom_film_grain_table_append(&table, 1000, 2000, film_grain_test_vectors + 0);
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));

	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));

	grain.bit_depth = film_grain_test_vectors[0].bit_depth;
	EXPECT_EQ(0, memcmp(&grain, film_grain_test_vectors + 0, sizeof(table)));

	// Extend the existing segment
	aom_film_grain_table_append(&table, 2000, 3000, film_grain_test_vectors + 0);
	EXPECT_EQ(0, table.head->next);

	// Lookup and remove and check that the entry is no longer there
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, true, &grain));
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));

	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, true, &grain));
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));

	EXPECT_EQ(0, table.head);
	EXPECT_EQ(0, table.tail);
	aom_film_grain_table_free(&table);
	}

	TEST(FilmGrainTableTest, AddSingleSegmentRemoveBiggerSegment) {
	aom_film_grain_table_t table;
	aom_film_grain_t grain;

	memset(&table, 0, sizeof(table));

	aom_film_grain_table_append(&table, 0, 1000, film_grain_test_vectors + 0);
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 0, 1100, true, &grain));

	EXPECT_EQ(0, table.head);
	EXPECT_EQ(0, table.tail);
	aom_film_grain_table_free(&table);
	}

	TEST(FilmGrainTableTest, SplitSingleSegment) {
	aom_film_grain_table_t table;
	aom_film_grain_t grain;
	memset(&table, 0, sizeof(table));

	aom_film_grain_table_append(&table, 0, 1000, film_grain_test_vectors + 0);

	// Test lookup and remove that adjusts start time
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 0, 100, true, &grain));
	EXPECT_EQ(nullptr, table.head->next);
	EXPECT_EQ(100, table.head->start_time);

	// Test lookup and remove that adjusts end time
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 900, 1000, true, &grain));
	EXPECT_EQ(nullptr, table.head->next);
	EXPECT_EQ(100, table.head->start_time);
	EXPECT_EQ(900, table.head->end_time);

	// Test lookup and remove that splits the first entry
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, 400, 600, true, &grain));
	EXPECT_EQ(100, table.head->start_time);
	EXPECT_EQ(400, table.head->end_time);

	ASSERT_NE(nullptr, table.head->next);
	EXPECT_EQ(table.tail, table.head->next);
	EXPECT_EQ(600, table.head->next->start_time);
	EXPECT_EQ(900, table.head->next->end_time);

	aom_film_grain_table_free(&table);
	}

	TEST(FilmGrainTableTest, AddAndLookupMultipleSegments) {
	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));

	aom_film_grain_t grain;
	const int kNumTestVectors =
	sizeof(film_grain_test_vectors) / sizeof(film_grain_test_vectors[0]);
	for (int i = 0; i < kNumTestVectors; ++i) {
	aom_film_grain_table_append(&table, i * 1000, (i + 1) * 1000,
	film_grain_test_vectors + i);
	}

	for (int i = kNumTestVectors - 1; i >= 0; --i) {
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
	true, &grain));
	grain_equal(film_grain_test_vectors + i, &grain);
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
	true, &grain));
	}

	// Verify that all the data has been removed
	for (int i = 0; i < kNumTestVectors; ++i) {
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
	true, &grain));
	}
	aom_film_grain_table_free(&table);
	}

	class FilmGrainTableIOTest : public ::testing::Test {
	protected:
	void SetUp() { memset(&error_, 0, sizeof(error_)); }
	struct aom_internal_error_info error_;
	};

	TEST_F(FilmGrainTableIOTest, ReadMissingFile) {
	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));
	ASSERT_EQ(AOM_CODEC_ERROR, aom_film_grain_table_read(
	&table, "/path/to/missing/file", &error_));
	}

	TEST_F(FilmGrainTableIOTest, ReadTruncatedFile) {
	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));

	std::string grain_file;
	FILE *file = libaom_test::GetTempOutFile(&grain_file);
	ASSERT_NE(file, nullptr);
	fwrite("deadbeef", 8, 1, file);
	fclose(file);
	ASSERT_EQ(AOM_CODEC_ERROR,
	aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
	EXPECT_EQ(0, remove(grain_file.c_str()));
	}

	TEST_F(FilmGrainTableIOTest, RoundTripReadWrite) {
	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));

	aom_film_grain_t expected_grain[16];
	const int kNumTestVectors =
	sizeof(film_grain_test_vectors) / sizeof(film_grain_test_vectors[0]);
	for (int i = 0; i < kNumTestVectors; ++i) {
	expected_grain[i] = film_grain_test_vectors[i];
	expected_grain[i].random_seed = i;
	expected_grain[i].update_parameters = i % 2;
	expected_grain[i].apply_grain = (i + 1) % 2;
	expected_grain[i].bit_depth = 0;
	aom_film_grain_table_append(&table, i * 1000, (i + 1) * 1000,
	expected_grain + i);
	}
	std::string grain_file;
	FILE *tmpfile = libaom_test::GetTempOutFile(&grain_file);
	ASSERT_NE(tmpfile, nullptr);
	fclose(tmpfile);
	ASSERT_EQ(AOM_CODEC_OK,
	aom_film_grain_table_write(&table, grain_file.c_str(), &error_));
	aom_film_grain_table_free(&table);

	memset(&table, 0, sizeof(table));
	ASSERT_EQ(AOM_CODEC_OK,
	aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
	for (int i = 0; i < kNumTestVectors; ++i) {
	aom_film_grain_t grain;
	EXPECT_TRUE(aom_film_grain_table_lookup(&table, i * 1000, (i + 1) * 1000,
	true, &grain));
	grain_equal(expected_grain + i, &grain);
	}
	aom_film_grain_table_free(&table);
	EXPECT_EQ(0, remove(grain_file.c_str()));
	}

	TEST_F(FilmGrainTableIOTest, RoundTripSplit) {
	std::string grain_file;
	FILE *tmpfile = libaom_test::GetTempOutFile(&grain_file);
	ASSERT_NE(tmpfile, nullptr);
	fclose(tmpfile);

	aom_film_grain_table_t table;
	memset(&table, 0, sizeof(table));

	aom_film_grain_t grain = film_grain_test_vectors[0];
	aom_film_grain_table_append(&table, 0, 3000, &grain);
	ASSERT_TRUE(aom_film_grain_table_lookup(&table, 1000, 2000, true, &grain));
	ASSERT_TRUE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
	EXPECT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));
	ASSERT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));
	ASSERT_EQ(AOM_CODEC_OK,
	aom_film_grain_table_write(&table, grain_file.c_str(), &error_));
	aom_film_grain_table_free(&table);

	memset(&table, 0, sizeof(table));
	ASSERT_EQ(AOM_CODEC_OK,
	aom_film_grain_table_read(&table, grain_file.c_str(), &error_));
	ASSERT_TRUE(aom_film_grain_table_lookup(&table, 0, 1000, false, &grain));
	ASSERT_FALSE(aom_film_grain_table_lookup(&table, 1000, 2000, false, &grain));
	ASSERT_TRUE(aom_film_grain_table_lookup(&table, 2000, 3000, false, &grain));
	aom_film_grain_table_free(&table);

	EXPECT_EQ(0, remove(grain_file.c_str()));
	}

	const ::libaom_test::TestMode kFilmGrainEncodeTestModes[] = {
	::libaom_test::kRealTime,
	#if !CONFIG_REALTIME_ONLY
	::libaom_test::kOnePassGood
	#endif
	};

	class FilmGrainEncodeTest
	: public ::libaom_test::CodecTestWith2Params<bool, ::libaom_test::TestMode>,
	public ::libaom_test::EncoderTest {
	protected:
	FilmGrainEncodeTest()
	: EncoderTest(GET_PARAM(0)), test_monochrome_(GET_PARAM(1)),
	test_mode_(GET_PARAM(2)) {}
	~FilmGrainEncodeTest() override = default;

	void SetUp() override {
	InitializeConfig(test_mode_);
	cfg_.monochrome = test_monochrome_;
	cfg_.rc_target_bitrate = 300;
	cfg_.kf_max_dist = 0;
	}

	void PreEncodeFrameHook(::libaom_test::VideoSource *video,
	::libaom_test::Encoder *encoder) override {
	if (video->frame() == 0) {
	encoder->Control(AOME_SET_CPUUSED, 5);
	encoder->Control(AV1E_SET_TUNE_CONTENT, AOM_CONTENT_FILM);
	encoder->Control(AV1E_SET_DENOISE_NOISE_LEVEL, 1);
	} else if (video->frame() == 1) {
	cfg_.monochrome = 0;
	encoder->Config(&cfg_);
	} else {
	cfg_.monochrome = test_monochrome_;
	encoder->Config(&cfg_);
	}
	}

	bool DoDecode() const override { return false; }

	void DoTest() {
	if (test_monochrome_ && test_mode_ == ::libaom_test::kRealTime) {
	// TODO(bohanli): Running real time mode with monochrome will cause the
	// encoder to crash. Check if this is intended or there is a bug.
	GTEST_SKIP();
	}
	::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352,
	288, 30, 1, 0, 3);
	cfg_.g_w = video.img()->d_w;
	cfg_.g_h = video.img()->d_h;
	ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
	}

	private:
	bool test_monochrome_;
	::libaom_test::TestMode test_mode_;
	};

	TEST_P(FilmGrainEncodeTest, Test) { DoTest(); }

	AV1_INSTANTIATE_TEST_SUITE(FilmGrainEncodeTest, ::testing::Bool(),
	::testing::ValuesIn(kFilmGrainEncodeTestModes));