test/y4m_test.cc

   1 /*
   2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10 */
  11
  12 #include <string>
  13
  14 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  15
  16 #include "./aom_config.h"
  17 #include "./y4menc.h"
  18 #include "test/md5_helper.h"
  19 #include "test/util.h"
  20 #include "test/y4m_video_source.h"
  21
  22 namespace {
  23
  24 using std::string;
  25
  26 static const unsigned int kWidth = 160;
  27 static const unsigned int kHeight = 90;
  28 static const unsigned int kFrames = 10;
  29
  30 struct Y4mTestParam {
  31   const char *filename;
  32   unsigned int bit_depth;
  33   aom_img_fmt format;
  34   const char *md5raw;
  35 };
  36
  37 const Y4mTestParam kY4mTestVectors[] = {
  38   { "park_joy_90p_8_420.y4m", 8, AOM_IMG_FMT_I420,
  39     "e5406275b9fc6bb3436c31d4a05c1cab" },
  40   { "park_joy_90p_8_422.y4m", 8, AOM_IMG_FMT_I422,
  41     "284a47a47133b12884ec3a14e959a0b6" },
  42   { "park_joy_90p_8_444.y4m", 8, AOM_IMG_FMT_I444,
  43     "90517ff33843d85de712fd4fe60dbed0" },
  44   { "park_joy_90p_10_420.y4m", 10, AOM_IMG_FMT_I42016,
  45     "63f21f9f717d8b8631bd2288ee87137b" },
  46   { "park_joy_90p_10_422.y4m", 10, AOM_IMG_FMT_I42216,
  47     "48ab51fb540aed07f7ff5af130c9b605" },
  48   { "park_joy_90p_10_444.y4m", 10, AOM_IMG_FMT_I44416,
  49     "067bfd75aa85ff9bae91fa3e0edd1e3e" },
  50   { "park_joy_90p_12_420.y4m", 12, AOM_IMG_FMT_I42016,
  51     "9e6d8f6508c6e55625f6b697bc461cef" },
  52   { "park_joy_90p_12_422.y4m", 12, AOM_IMG_FMT_I42216,
  53     "b239c6b301c0b835485be349ca83a7e3" },
  54   { "park_joy_90p_12_444.y4m", 12, AOM_IMG_FMT_I44416,
  55     "5a6481a550821dab6d0192f5c63845e9" },
  56 };
  57
  58 static void write_image_file(const aom_image_t *img, FILE *file) {
  59   int plane, y;
  60   for (plane = 0; plane < 3; ++plane) {
  61     const unsigned char *buf = img->planes[plane];
  62     const int stride = img->stride[plane];
  63     const int bytes_per_sample = (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
  64     const int h =
  65         (plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
  66                : img->d_h);
  67     const int w =
  68         (plane ? (img->d_w + img->x_chroma_shift) >> img->x_chroma_shift
  69                : img->d_w);
  70     for (y = 0; y < h; ++y) {
  71       fwrite(buf, bytes_per_sample, w, file);
  72       buf += stride;
  73     }
  74   }
  75 }
  76
  77 class Y4mVideoSourceTest : public ::testing::TestWithParam<Y4mTestParam>,
  78                            public ::libaom_test::Y4mVideoSource {
  79  protected:
  80   Y4mVideoSourceTest() : Y4mVideoSource("", 0, 0) {}
  81
  82   virtual ~Y4mVideoSourceTest() { CloseSource(); }
  83
  84   virtual void Init(const std::string &file_name, int limit) {
  85     file_name_ = file_name;
  86     start_ = 0;
  87     limit_ = limit;
  88     frame_ = 0;
  89     Begin();
  90   }
  91
  92   // Checks y4m header information
  93   void HeaderChecks(unsigned int bit_depth, aom_img_fmt_t fmt) {
  94     ASSERT_TRUE(input_file_ != NULL);
  95     ASSERT_EQ(y4m_.pic_w, (int)kWidth);
  96     ASSERT_EQ(y4m_.pic_h, (int)kHeight);
  97     ASSERT_EQ(img()->d_w, kWidth);
  98     ASSERT_EQ(img()->d_h, kHeight);
  99     ASSERT_EQ(y4m_.bit_depth, bit_depth);
 100     ASSERT_EQ(y4m_.aom_fmt, fmt);
 101     if (fmt == AOM_IMG_FMT_I420 || fmt == AOM_IMG_FMT_I42016) {
 102       ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 3 / 2);
 103       ASSERT_EQ(img()->x_chroma_shift, 1U);
 104       ASSERT_EQ(img()->y_chroma_shift, 1U);
 105     }
 106     if (fmt == AOM_IMG_FMT_I422 || fmt == AOM_IMG_FMT_I42216) {
 107       ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 2);
 108       ASSERT_EQ(img()->x_chroma_shift, 1U);
 109       ASSERT_EQ(img()->y_chroma_shift, 0U);
 110     }
 111     if (fmt == AOM_IMG_FMT_I444 || fmt == AOM_IMG_FMT_I44416) {
 112       ASSERT_EQ(y4m_.bps, (int)y4m_.bit_depth * 3);
 113       ASSERT_EQ(img()->x_chroma_shift, 0U);
 114       ASSERT_EQ(img()->y_chroma_shift, 0U);
 115     }
 116   }
 117
 118   // Checks MD5 of the raw frame data
 119   void Md5Check(const string &expected_md5) {
 120     ASSERT_TRUE(input_file_ != NULL);
 121     libaom_test::MD5 md5;
 122     for (unsigned int i = start_; i < limit_; i++) {
 123       md5.Add(img());
 124       Next();
 125     }
 126     ASSERT_EQ(string(md5.Get()), expected_md5);
 127   }
 128 };
 129
 130 TEST_P(Y4mVideoSourceTest, SourceTest) {
 131   const Y4mTestParam t = GetParam();
 132   Init(t.filename, kFrames);
 133   HeaderChecks(t.bit_depth, t.format);
 134   Md5Check(t.md5raw);
 135 }
 136
 137 INSTANTIATE_TEST_CASE_P(C, Y4mVideoSourceTest,
 138                         ::testing::ValuesIn(kY4mTestVectors));
 139
 140 class Y4mVideoWriteTest : public Y4mVideoSourceTest {
 141  protected:
 142   Y4mVideoWriteTest() : tmpfile_(NULL) {}
 143
 144   virtual ~Y4mVideoWriteTest() {
 145     delete tmpfile_;
 146     input_file_ = NULL;
 147   }
 148
 149   void ReplaceInputFile(FILE *input_file) {
 150     CloseSource();
 151     frame_ = 0;
 152     input_file_ = input_file;
 153     rewind(input_file_);
 154     ReadSourceToStart();
 155   }
 156
 157   // Writes out a y4m file and then reads it back
 158   void WriteY4mAndReadBack() {
 159     ASSERT_TRUE(input_file_ != NULL);
 160     char buf[Y4M_BUFFER_SIZE] = { 0 };
 161     const struct AvxRational framerate = { y4m_.fps_n, y4m_.fps_d };
 162     tmpfile_ = new libaom_test::TempOutFile;
 163     ASSERT_TRUE(tmpfile_->file() != NULL);
 164     y4m_write_file_header(buf, sizeof(buf), kWidth, kHeight, &framerate,
 165                           y4m_.aom_fmt, y4m_.bit_depth);
 166     fputs(buf, tmpfile_->file());
 167     for (unsigned int i = start_; i < limit_; i++) {
 168       y4m_write_frame_header(buf, sizeof(buf));
 169       fputs(buf, tmpfile_->file());
 170       write_image_file(img(), tmpfile_->file());
 171       Next();
 172     }
 173     ReplaceInputFile(tmpfile_->file());
 174   }
 175
 176   virtual void Init(const std::string &file_name, int limit) {
 177     Y4mVideoSourceTest::Init(file_name, limit);
 178     WriteY4mAndReadBack();
 179   }
 180   libaom_test::TempOutFile *tmpfile_;
 181 };
 182
 183 TEST_P(Y4mVideoWriteTest, WriteTest) {
 184   const Y4mTestParam t = GetParam();
 185   Init(t.filename, kFrames);
 186   HeaderChecks(t.bit_depth, t.format);
 187   Md5Check(t.md5raw);
 188 }
 189
 190 INSTANTIATE_TEST_CASE_P(C, Y4mVideoWriteTest,
 191                         ::testing::ValuesIn(kY4mTestVectors));
 192 }  // namespace