coding_path_sync.cc 5.47 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * Copyright (c) 2016, 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 <vector>
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
#include "test/acm_random.h"

#include "./aom_config.h"

#include "aom_ports/mem.h"  // ROUND_POWER_OF_TWO
#include "aom/aomcx.h"
#include "aom/aomdx.h"
#include "aom/aom_encoder.h"
#include "aom/aom_decoder.h"

using libaom_test::ACMRandom;
namespace {

27 28 29
class CompressedSource {
 public:
  explicit CompressedSource(int seed) : rnd_(seed), frame_count_(0) {
30 31 32 33 34
    aom_codec_iface_t *algo = &aom_codec_av1_cx_algo;

    aom_codec_enc_cfg_t cfg;
    aom_codec_enc_config_default(algo, &cfg, 0);

35 36 37 38 39 40
    // force the quantizer, to reduce the sensitivity on encoding choices.
    // e.g, we don't want this test to break when the rate control is modified.
    {
      const int max_q = cfg.rc_max_quantizer;
      const int min_q = cfg.rc_min_quantizer;
      const int q = rnd_.PseudoUniform(max_q - min_q + 1) + min_q;
41

42 43 44 45
      cfg.rc_end_usage = AOM_Q;
      cfg.rc_max_quantizer = q;
      cfg.rc_min_quantizer = q;
    }
46 47 48 49 50 51 52

    // choose the picture size
    {
      width_ = rnd_.PseudoUniform(kWidth - 8) + 8;
      height_ = rnd_.PseudoUniform(kHeight - 8) + 8;
    }

53 54 55
    // choose the chroma subsampling
    {
      const aom_img_fmt_t fmts[] = {
Johann's avatar
Johann committed
56 57 58
        AOM_IMG_FMT_I420,
        AOM_IMG_FMT_I422,
        AOM_IMG_FMT_I444,
59 60 61 62 63
      };

      format_ = fmts[rnd_.PseudoUniform(NELEMENTS(fmts))];
    }

64 65
    cfg.g_w = width_;
    cfg.g_h = height_;
66
    cfg.g_lag_in_frames = 0;
67 68 69 70 71 72
    if (format_ == AOM_IMG_FMT_I420)
      cfg.g_profile = 0;
    else if (format_ == AOM_IMG_FMT_I444)
      cfg.g_profile = 1;
    else if (format_ == AOM_IMG_FMT_I422)
      cfg.g_profile = 2;
73 74 75 76 77 78

    aom_codec_enc_init(&enc_, algo, &cfg, 0);
  }

  ~CompressedSource() { aom_codec_destroy(&enc_); }

79
  const aom_codec_cx_pkt_t *ReadFrame() {
80
    uint8_t buf[kWidth * kHeight * 3] = { 0 };
81 82 83 84 85 86 87

    // render regular pattern
    const int period = rnd_.Rand8() % 32 + 1;
    const int phase = rnd_.Rand8() % period;

    const int val_a = rnd_.Rand8();
    const int val_b = rnd_.Rand8();
88

89 90 91 92
    for (int i = 0; i < (int)sizeof buf; ++i)
      buf[i] = (i + phase) % period < period / 2 ? val_a : val_b;

    aom_image_t img;
93
    aom_img_wrap(&img, format_, width_, height_, 0, buf);
Sean DuBois's avatar
Sean DuBois committed
94
    aom_codec_encode(&enc_, &img, frame_count_++, 1, 0);
95 96

    aom_codec_iter_t iter = NULL;
97 98 99 100 101 102 103 104

    const aom_codec_cx_pkt_t *pkt = NULL;

    do {
      pkt = aom_codec_get_cx_data(&enc_, &iter);
    } while (pkt && pkt->kind != AOM_CODEC_CX_FRAME_PKT);

    return pkt;
105 106 107
  }

 private:
108 109
  static const int kWidth = 128;
  static const int kHeight = 128;
110

111
  ACMRandom rnd_;
112
  aom_img_fmt_t format_;
113 114
  aom_codec_ctx_t enc_;
  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 121
  std::vector<int16_t> bytes;
  bytes.reserve(img->d_w * img->d_h * 3);
122
  for (int plane = 0; plane < 3; ++plane) {
123 124 125 126 127
    const int w = aom_img_plane_width(img, plane);
    const int h = aom_img_plane_height(img, plane);

    for (int r = 0; r < h; ++r) {
      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 138 139

  return bytes;
}

140 141
class Decoder {
 public:
142 143 144
  explicit Decoder(int allowLowbitdepth) {
    aom_codec_iface_t *algo = &aom_codec_av1_dx_algo;

145
    aom_codec_dec_cfg_t cfg = aom_codec_dec_cfg_t();
146 147 148 149 150 151 152 153
    cfg.allow_lowbitdepth = allowLowbitdepth;

    aom_codec_dec_init(&dec_, algo, &cfg, 0);
  }

  ~Decoder() { aom_codec_destroy(&dec_); }

  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),
Sean DuBois's avatar
Sean DuBois committed
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 162 163 164 165 166
  }

 private:
  aom_codec_ctx_t dec_;
};

// Try to reveal a mismatch between LBD and HBD coding paths.
TEST(CodingPathSync, SearchForHbdLbdMismatch) {
167
  const int count_tests = 10;
168
  for (int i = 0; i < count_tests; ++i) {
169 170
    Decoder dec_hbd(0);
    Decoder dec_lbd(1);
171 172

    CompressedSource enc(i);
173

174 175 176 177 178 179 180 181 182 183
    for (int k = 0; k < 3; ++k) {
      const aom_codec_cx_pkt_t *frame = enc.ReadFrame();

      std::vector<int16_t> lbd_yuv = dec_lbd.decode(frame);
      std::vector<int16_t> hbd_yuv = dec_hbd.decode(frame);

      ASSERT_EQ(lbd_yuv, hbd_yuv);
    }
  }
}
184

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
TEST(CodingPathSyncLarge, SearchForHbdLbdMismatchLarge) {
  const int count_tests = 100;
  const int seed = 1234;
  for (int i = 0; i < count_tests; ++i) {
    Decoder dec_hbd(0);
    Decoder dec_lbd(1);

    CompressedSource enc(seed + i);

    for (int k = 0; k < 5; ++k) {
      const aom_codec_cx_pkt_t *frame = enc.ReadFrame();

      std::vector<int16_t> lbd_yuv = dec_lbd.decode(frame);
      std::vector<int16_t> hbd_yuv = dec_hbd.decode(frame);

      ASSERT_EQ(lbd_yuv, hbd_yuv);
    }
202 203 204 205
  }
}

}  // namespace