test/coding_path_sync.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 <vector>
  13 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  14 #include "test/acm_random.h"
  15
  16 #include "./aom_config.h"
  17
  18 #include "aom_ports/mem.h"  // ROUND_POWER_OF_TWO
  19 #include "aom/aomcx.h"
  20 #include "aom/aomdx.h"
  21 #include "aom/aom_encoder.h"
  22 #include "aom/aom_decoder.h"
  23
  24 using libaom_test::ACMRandom;
  25 namespace {
  26
  27 class CompressedSource {
  28  public:
  29   explicit CompressedSource(int seed) : rnd_(seed), frame_count_(0) {
  30     aom_codec_iface_t *algo = &aom_codec_av1_cx_algo;
  31
  32     aom_codec_enc_cfg_t cfg;
  33     aom_codec_enc_config_default(algo, &cfg, 0);
  34
  35     // force the quantizer, to reduce the sensitivity on encoding choices.
  36     // e.g, we don't want this test to break when the rate control is modified.
  37     {
  38       const int max_q = cfg.rc_max_quantizer;
  39       const int min_q = cfg.rc_min_quantizer;
  40       const int q = rnd_.PseudoUniform(max_q - min_q + 1) + min_q;
  41
  42       cfg.rc_end_usage = AOM_Q;
  43       cfg.rc_max_quantizer = q;
  44       cfg.rc_min_quantizer = q;
  45     }
  46
  47     // choose the picture size
  48     {
  49       width_ = rnd_.PseudoUniform(kWidth - 8) + 8;
  50       height_ = rnd_.PseudoUniform(kHeight - 8) + 8;
  51     }
  52
  53     // choose the chroma subsampling
  54     {
  55       const aom_img_fmt_t fmts[] = {
  56         AOM_IMG_FMT_I420,
  57         AOM_IMG_FMT_I422,
  58         AOM_IMG_FMT_I444,
  59       };
  60
  61       format_ = fmts[rnd_.PseudoUniform(NELEMENTS(fmts))];
  62     }
  63
  64     cfg.g_w = width_;
  65     cfg.g_h = height_;
  66     cfg.g_lag_in_frames = 0;
  67     if (format_ == AOM_IMG_FMT_I420)
  68       cfg.g_profile = 0;
  69     else if (format_ == AOM_IMG_FMT_I444)
  70       cfg.g_profile = 1;
  71     else if (format_ == AOM_IMG_FMT_I422)
  72       cfg.g_profile = 2;
  73
  74     aom_codec_enc_init(&enc_, algo, &cfg, 0);
  75   }
  76
  77   ~CompressedSource() { aom_codec_destroy(&enc_); }
  78
  79   const aom_codec_cx_pkt_t *ReadFrame() {
  80     uint8_t buf[kWidth * kHeight * 3] = { 0 };
  81
  82     // render regular pattern
  83     const int period = rnd_.Rand8() % 32 + 1;
  84     const int phase = rnd_.Rand8() % period;
  85
  86     const int val_a = rnd_.Rand8();
  87     const int val_b = rnd_.Rand8();
  88
  89     for (int i = 0; i < (int)sizeof buf; ++i)
  90       buf[i] = (i + phase) % period < period / 2 ? val_a : val_b;
  91
  92     aom_image_t img;
  93     aom_img_wrap(&img, format_, width_, height_, 0, buf);
  94     aom_codec_encode(&enc_, &img, frame_count_++, 1, 0);
  95
  96     aom_codec_iter_t iter = NULL;
  97
  98     const aom_codec_cx_pkt_t *pkt = NULL;
  99
 100     do {
 101       pkt = aom_codec_get_cx_data(&enc_, &iter);
 102     } while (pkt && pkt->kind != AOM_CODEC_CX_FRAME_PKT);
 103
 104     return pkt;
 105   }
 106
 107  private:
 108   static const int kWidth = 128;
 109   static const int kHeight = 128;
 110
 111   ACMRandom rnd_;
 112   aom_img_fmt_t format_;
 113   aom_codec_ctx_t enc_;
 114   int frame_count_;
 115   int width_, height_;
 116 };
 117
 118 // lowers an aom_image_t to a easily comparable/printable form
 119 std::vector<int16_t> Serialize(const aom_image_t *img) {
 120   std::vector<int16_t> bytes;
 121   bytes.reserve(img->d_w * img->d_h * 3);
 122   for (int plane = 0; plane < 3; ++plane) {
 123     const int w = aom_img_plane_width(img, plane);
 124     const int h = aom_img_plane_height(img, plane);
 125
 126     for (int r = 0; r < h; ++r) {
 127       for (int c = 0; c < w; ++c) {
 128         unsigned char *row = img->planes[plane] + r * img->stride[plane];
 129         if (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH)
 130           bytes.push_back(row[c * 2]);
 131         else
 132           bytes.push_back(row[c]);
 133       }
 134     }
 135   }
 136
 137   return bytes;
 138 }
 139
 140 class Decoder {
 141  public:
 142   explicit Decoder(int allowLowbitdepth) {
 143     aom_codec_iface_t *algo = &aom_codec_av1_dx_algo;
 144
 145     aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
 146     cfg.allow_lowbitdepth = allowLowbitdepth;
 147
 148     aom_codec_dec_init(&dec_, algo, &cfg, 0);
 149   }
 150
 151   ~Decoder() { aom_codec_destroy(&dec_); }
 152
 153   std::vector<int16_t> decode(const aom_codec_cx_pkt_t *pkt) {
 154     aom_codec_decode(&dec_, static_cast<uint8_t *>(pkt->data.frame.buf),
 155                      static_cast<unsigned int>(pkt->data.frame.sz), NULL);
 156
 157     aom_codec_iter_t iter = NULL;
 158     return Serialize(aom_codec_get_frame(&dec_, &iter));
 159   }
 160
 161  private:
 162   aom_codec_ctx_t dec_;
 163 };
 164
 165 // Try to reveal a mismatch between LBD and HBD coding paths.
 166 TEST(CodingPathSync, SearchForHbdLbdMismatch) {
 167   const int count_tests = 10;
 168   for (int i = 0; i < count_tests; ++i) {
 169     Decoder dec_hbd(0);
 170     Decoder dec_lbd(1);
 171
 172     CompressedSource enc(i);
 173
 174     for (int k = 0; k < 3; ++k) {
 175       const aom_codec_cx_pkt_t *frame = enc.ReadFrame();
 176
 177       std::vector<int16_t> lbd_yuv = dec_lbd.decode(frame);
 178       std::vector<int16_t> hbd_yuv = dec_hbd.decode(frame);
 179
 180       ASSERT_EQ(lbd_yuv, hbd_yuv);
 181     }
 182   }
 183 }
 184
 185 TEST(CodingPathSyncLarge, SearchForHbdLbdMismatchLarge) {
 186   const int count_tests = 100;
 187   const int seed = 1234;
 188   for (int i = 0; i < count_tests; ++i) {
 189     Decoder dec_hbd(0);
 190     Decoder dec_lbd(1);
 191
 192     CompressedSource enc(seed + i);
 193
 194     for (int k = 0; k < 5; ++k) {
 195       const aom_codec_cx_pkt_t *frame = enc.ReadFrame();
 196
 197       std::vector<int16_t> lbd_yuv = dec_lbd.decode(frame);
 198       std::vector<int16_t> hbd_yuv = dec_hbd.decode(frame);
 199
 200       ASSERT_EQ(lbd_yuv, hbd_yuv);
 201     }
 202   }
 203 }
 204
 205 }  // namespace