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 "config/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:
CompressedSource(int seed)29 explicit CompressedSource(int seed) : rnd_(seed), frame_count_(0) {
30 aom_codec_iface_t *algo = aom_codec_av1_cx();
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
~CompressedSource()77 ~CompressedSource() { aom_codec_destroy(&enc_); }
78
ReadFrame()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
Serialize(const aom_image_t * img)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:
Decoder(int allowLowbitdepth)142 explicit Decoder(int allowLowbitdepth) {
143 aom_codec_iface_t *algo = aom_codec_av1_dx();
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
~Decoder()151 ~Decoder() { aom_codec_destroy(&dec_); }
152
decode(const aom_codec_cx_pkt_t * pkt)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 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.
TEST(CodingPathSync,SearchForHbdLbdMismatch)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
TEST(CodingPathSyncLarge,SearchForHbdLbdMismatchLarge)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
206