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 <cassert>
13 #include <climits>
14 #include <cstdint>
15 #include <cstdlib>
16 #include <cstring>
17 #include <tuple>
18
19 #include "gtest/gtest.h"
20
21 #include "config/aom_config.h"
22
23 #include "aom/aomcx.h"
24 #include "aom/aom_encoder.h"
25 #include "aom/aom_image.h"
26
27 namespace {
28
29 #if CONFIG_REALTIME_ONLY
30 const unsigned int kUsage = AOM_USAGE_REALTIME;
31 #else
32 const unsigned int kUsage = AOM_USAGE_GOOD_QUALITY;
33 #endif
34
Memset16(void * dest,int val,size_t length)35 static void *Memset16(void *dest, int val, size_t length) {
36 uint16_t *dest16 = (uint16_t *)dest;
37 for (size_t i = 0; i < length; ++i) *dest16++ = val;
38 return dest;
39 }
40
TEST(EncodeAPI,InvalidParams)41 TEST(EncodeAPI, InvalidParams) {
42 uint8_t buf[1] = { 0 };
43 aom_image_t img;
44 aom_codec_ctx_t enc;
45 aom_codec_enc_cfg_t cfg;
46
47 EXPECT_EQ(&img, aom_img_wrap(&img, AOM_IMG_FMT_I420, 1, 1, 1, buf));
48
49 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
50 aom_codec_enc_init(nullptr, nullptr, nullptr, 0));
51 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
52 aom_codec_enc_init(&enc, nullptr, nullptr, 0));
53 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
54 aom_codec_encode(nullptr, nullptr, 0, 0, 0));
55 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_encode(nullptr, &img, 0, 0, 0));
56 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_destroy(nullptr));
57 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
58 aom_codec_enc_config_default(nullptr, nullptr, 0));
59 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
60 aom_codec_enc_config_default(nullptr, &cfg, 0));
61 EXPECT_NE(aom_codec_error(nullptr), nullptr);
62
63 aom_codec_iface_t *iface = aom_codec_av1_cx();
64 SCOPED_TRACE(aom_codec_iface_name(iface));
65 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
66 aom_codec_enc_init(nullptr, iface, nullptr, 0));
67 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
68 aom_codec_enc_init(&enc, iface, nullptr, 0));
69 EXPECT_EQ(AOM_CODEC_INVALID_PARAM,
70 aom_codec_enc_config_default(iface, &cfg, 3));
71 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
72 cfg.g_w = 1 << 16;
73 cfg.g_h = (1 << 14) + 1;
74 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
75 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
76 cfg.g_w = (1 << 14) + 1;
77 cfg.g_h = 1 << 16;
78 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
79 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
80 cfg.g_forced_max_frame_width = 1 << 16;
81 cfg.g_forced_max_frame_height = (1 << 14) + 1;
82 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
83 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
84 cfg.g_forced_max_frame_width = (1 << 14) + 1;
85 cfg.g_forced_max_frame_height = 1 << 16;
86 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
87 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
88 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0));
89 EXPECT_EQ(nullptr, aom_codec_get_global_headers(nullptr));
90
91 aom_fixed_buf_t *glob_headers = aom_codec_get_global_headers(&enc);
92 EXPECT_NE(glob_headers->buf, nullptr);
93 if (glob_headers) {
94 free(glob_headers->buf);
95 free(glob_headers);
96 }
97 EXPECT_EQ(AOM_CODEC_OK, aom_codec_encode(&enc, nullptr, 0, 0, 0));
98 EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
99 }
100
TEST(EncodeAPI,InvalidControlId)101 TEST(EncodeAPI, InvalidControlId) {
102 aom_codec_iface_t *iface = aom_codec_av1_cx();
103 aom_codec_ctx_t enc;
104 aom_codec_enc_cfg_t cfg;
105 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
106 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0));
107 EXPECT_EQ(AOM_CODEC_ERROR, aom_codec_control(&enc, -1, 0));
108 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_control(&enc, 0, 0));
109 EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
110 }
111
EncodeSetSFrameOnFirstFrame(aom_img_fmt fmt,aom_codec_flags_t flag)112 void EncodeSetSFrameOnFirstFrame(aom_img_fmt fmt, aom_codec_flags_t flag) {
113 constexpr int kWidth = 2;
114 constexpr int kHeight = 128;
115 unsigned char kBuffer[kWidth * kHeight * 3] = { 0 };
116 aom_image_t img;
117 ASSERT_EQ(aom_img_wrap(&img, fmt, kWidth, kHeight, 1, kBuffer), &img);
118
119 aom_codec_iface_t *iface = aom_codec_av1_cx();
120 aom_codec_enc_cfg_t cfg;
121 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, kUsage), AOM_CODEC_OK);
122 cfg.g_w = kWidth;
123 cfg.g_h = kHeight;
124
125 aom_codec_ctx_t enc;
126 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, flag), AOM_CODEC_OK);
127 // One of these aom_codec_encode() calls should fail.
128 if (aom_codec_encode(&enc, &img, 0, 1, AOM_EFLAG_SET_S_FRAME) ==
129 AOM_CODEC_OK) {
130 EXPECT_NE(aom_codec_encode(&enc, nullptr, 0, 0, 0), AOM_CODEC_OK);
131 }
132 EXPECT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
133 }
134
TEST(EncodeAPI,SetSFrameOnFirstFrame)135 TEST(EncodeAPI, SetSFrameOnFirstFrame) {
136 EncodeSetSFrameOnFirstFrame(AOM_IMG_FMT_I420, 0);
137 }
138
139 #if CONFIG_AV1_HIGHBITDEPTH
TEST(EncodeAPI,SetSFrameOnFirstFrameHighbd)140 TEST(EncodeAPI, SetSFrameOnFirstFrameHighbd) {
141 EncodeSetSFrameOnFirstFrame(AOM_IMG_FMT_I42016, AOM_CODEC_USE_HIGHBITDEPTH);
142 }
143 #endif // CONFIG_AV1_HIGHBITDEPTH
144
TEST(EncodeAPI,MonochromeInProfiles)145 TEST(EncodeAPI, MonochromeInProfiles) {
146 aom_codec_iface_t *iface = aom_codec_av1_cx();
147 aom_codec_enc_cfg_t cfg;
148 ASSERT_EQ(AOM_CODEC_OK, aom_codec_enc_config_default(iface, &cfg, kUsage));
149 cfg.g_w = 128;
150 cfg.g_h = 128;
151 cfg.monochrome = 1;
152 aom_codec_ctx_t enc;
153
154 // Test Profile 0
155 cfg.g_profile = 0;
156 ASSERT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0));
157 EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
158
159 // Test Profile 1
160 cfg.g_profile = 1;
161 ASSERT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
162
163 // Test Profile 3
164 cfg.g_profile = 2;
165 ASSERT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0));
166 EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
167 }
168
TEST(EncodeAPI,LowBDEncoderLowBDImage)169 TEST(EncodeAPI, LowBDEncoderLowBDImage) {
170 aom_codec_iface_t *iface = aom_codec_av1_cx();
171 aom_codec_enc_cfg_t cfg;
172 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, kUsage), AOM_CODEC_OK);
173
174 aom_codec_ctx_t enc;
175 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
176
177 aom_image_t *image =
178 aom_img_alloc(nullptr, AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h, 0);
179 ASSERT_NE(image, nullptr);
180
181 // Set the image to two colors so that av1_set_screen_content_options() will
182 // call av1_get_perpixel_variance().
183 int luma_value = 0;
184 for (unsigned int i = 0; i < image->d_h; ++i) {
185 memset(image->planes[0] + i * image->stride[0], luma_value, image->d_w);
186 luma_value = 255 - luma_value;
187 }
188 unsigned int uv_h = (image->d_h + 1) / 2;
189 unsigned int uv_w = (image->d_w + 1) / 2;
190 for (unsigned int i = 0; i < uv_h; ++i) {
191 memset(image->planes[1] + i * image->stride[1], 128, uv_w);
192 memset(image->planes[2] + i * image->stride[2], 128, uv_w);
193 }
194
195 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
196
197 aom_img_free(image);
198 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
199 }
200
TEST(EncodeAPI,HighBDEncoderHighBDImage)201 TEST(EncodeAPI, HighBDEncoderHighBDImage) {
202 aom_codec_iface_t *iface = aom_codec_av1_cx();
203 aom_codec_enc_cfg_t cfg;
204 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, kUsage), AOM_CODEC_OK);
205
206 aom_codec_ctx_t enc;
207 aom_codec_err_t init_status =
208 aom_codec_enc_init(&enc, iface, &cfg, AOM_CODEC_USE_HIGHBITDEPTH);
209 #if !CONFIG_AV1_HIGHBITDEPTH
210 ASSERT_EQ(init_status, AOM_CODEC_INCAPABLE);
211 #else
212 ASSERT_EQ(init_status, AOM_CODEC_OK);
213
214 aom_image_t *image =
215 aom_img_alloc(nullptr, AOM_IMG_FMT_I42016, cfg.g_w, cfg.g_h, 0);
216 ASSERT_NE(image, nullptr);
217
218 // Set the image to two colors so that av1_set_screen_content_options() will
219 // call av1_get_perpixel_variance().
220 int luma_value = 0;
221 for (unsigned int i = 0; i < image->d_h; ++i) {
222 Memset16(image->planes[0] + i * image->stride[0], luma_value, image->d_w);
223 luma_value = 255 - luma_value;
224 }
225 unsigned int uv_h = (image->d_h + 1) / 2;
226 unsigned int uv_w = (image->d_w + 1) / 2;
227 for (unsigned int i = 0; i < uv_h; ++i) {
228 Memset16(image->planes[1] + i * image->stride[1], 128, uv_w);
229 Memset16(image->planes[2] + i * image->stride[2], 128, uv_w);
230 }
231
232 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
233
234 aom_img_free(image);
235 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
236 #endif
237 }
238
TEST(EncodeAPI,HighBDEncoderLowBDImage)239 TEST(EncodeAPI, HighBDEncoderLowBDImage) {
240 aom_codec_iface_t *iface = aom_codec_av1_cx();
241 aom_codec_enc_cfg_t cfg;
242 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, kUsage), AOM_CODEC_OK);
243
244 aom_codec_ctx_t enc;
245 aom_codec_err_t init_status =
246 aom_codec_enc_init(&enc, iface, &cfg, AOM_CODEC_USE_HIGHBITDEPTH);
247 #if !CONFIG_AV1_HIGHBITDEPTH
248 ASSERT_EQ(init_status, AOM_CODEC_INCAPABLE);
249 #else
250 ASSERT_EQ(init_status, AOM_CODEC_OK);
251
252 aom_image_t *image =
253 aom_img_alloc(nullptr, AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h, 0);
254 ASSERT_NE(image, nullptr);
255
256 // Set the image to two colors so that av1_set_screen_content_options() will
257 // call av1_get_perpixel_variance().
258 int luma_value = 0;
259 for (unsigned int i = 0; i < image->d_h; ++i) {
260 memset(image->planes[0] + i * image->stride[0], luma_value, image->d_w);
261 luma_value = 255 - luma_value;
262 }
263 unsigned int uv_h = (image->d_h + 1) / 2;
264 unsigned int uv_w = (image->d_w + 1) / 2;
265 for (unsigned int i = 0; i < uv_h; ++i) {
266 memset(image->planes[1] + i * image->stride[1], 128, uv_w);
267 memset(image->planes[2] + i * image->stride[2], 128, uv_w);
268 }
269
270 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_INVALID_PARAM);
271
272 aom_img_free(image);
273 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
274 #endif
275 }
276
TEST(EncodeAPI,LowBDEncoderHighBDImage)277 TEST(EncodeAPI, LowBDEncoderHighBDImage) {
278 aom_codec_iface_t *iface = aom_codec_av1_cx();
279 aom_codec_enc_cfg_t cfg;
280 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, kUsage), AOM_CODEC_OK);
281
282 aom_codec_ctx_t enc;
283 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
284
285 aom_image_t *image =
286 aom_img_alloc(nullptr, AOM_IMG_FMT_I42016, cfg.g_w, cfg.g_h, 0);
287 ASSERT_NE(image, nullptr);
288
289 // Set the image to two colors so that av1_set_screen_content_options() will
290 // call av1_get_perpixel_variance().
291 int luma_value = 0;
292 for (unsigned int i = 0; i < image->d_h; ++i) {
293 Memset16(image->planes[0] + i * image->stride[0], luma_value, image->d_w);
294 luma_value = 255 - luma_value;
295 }
296 unsigned int uv_h = (image->d_h + 1) / 2;
297 unsigned int uv_w = (image->d_w + 1) / 2;
298 for (unsigned int i = 0; i < uv_h; ++i) {
299 Memset16(image->planes[1] + i * image->stride[1], 128, uv_w);
300 Memset16(image->planes[2] + i * image->stride[2], 128, uv_w);
301 }
302
303 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_INVALID_PARAM);
304
305 aom_img_free(image);
306 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
307 }
308
CreateGrayImage(aom_img_fmt_t fmt,unsigned int w,unsigned int h)309 aom_image_t *CreateGrayImage(aom_img_fmt_t fmt, unsigned int w,
310 unsigned int h) {
311 aom_image_t *const image = aom_img_alloc(nullptr, fmt, w, h, 1);
312 if (!image) return image;
313
314 for (unsigned int i = 0; i < image->d_h; ++i) {
315 memset(image->planes[0] + i * image->stride[0], 128, image->d_w);
316 }
317 const unsigned int uv_h = (image->d_h + 1) / 2;
318 const unsigned int uv_w = (image->d_w + 1) / 2;
319 for (unsigned int i = 0; i < uv_h; ++i) {
320 memset(image->planes[1] + i * image->stride[1], 128, uv_w);
321 memset(image->planes[2] + i * image->stride[2], 128, uv_w);
322 }
323 return image;
324 }
325
TEST(EncodeAPI,Buganizer310548198)326 TEST(EncodeAPI, Buganizer310548198) {
327 aom_codec_iface_t *const iface = aom_codec_av1_cx();
328 aom_codec_enc_cfg_t cfg;
329 const unsigned int usage = AOM_USAGE_REALTIME;
330 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, usage), AOM_CODEC_OK);
331 cfg.g_w = 1;
332 cfg.g_h = 444;
333 cfg.g_pass = AOM_RC_ONE_PASS;
334 cfg.g_lag_in_frames = 0;
335
336 aom_codec_ctx_t enc;
337 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
338
339 const int speed = 6;
340 ASSERT_EQ(aom_codec_control(&enc, AOME_SET_CPUUSED, speed), AOM_CODEC_OK);
341
342 const aom_enc_frame_flags_t flags = 0;
343 int frame_index = 0;
344
345 // Encode a frame.
346 aom_image_t *image = CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
347 ASSERT_NE(image, nullptr);
348 ASSERT_EQ(aom_codec_encode(&enc, image, frame_index, 1, flags), AOM_CODEC_OK);
349 frame_index++;
350 const aom_codec_cx_pkt_t *pkt;
351 aom_codec_iter_t iter = nullptr;
352 while ((pkt = aom_codec_get_cx_data(&enc, &iter)) != nullptr) {
353 ASSERT_EQ(pkt->kind, AOM_CODEC_CX_FRAME_PKT);
354 }
355 aom_img_free(image);
356
357 cfg.g_w = 1;
358 cfg.g_h = 254;
359 ASSERT_EQ(aom_codec_enc_config_set(&enc, &cfg), AOM_CODEC_OK)
360 << aom_codec_error_detail(&enc);
361
362 cfg.g_w = 1;
363 cfg.g_h = 154;
364 ASSERT_EQ(aom_codec_enc_config_set(&enc, &cfg), AOM_CODEC_OK)
365 << aom_codec_error_detail(&enc);
366
367 // Encode a frame.
368 image = CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
369 ASSERT_EQ(aom_codec_encode(&enc, image, frame_index, 1, flags), AOM_CODEC_OK);
370 frame_index++;
371 iter = nullptr;
372 while ((pkt = aom_codec_get_cx_data(&enc, &iter)) != nullptr) {
373 ASSERT_EQ(pkt->kind, AOM_CODEC_CX_FRAME_PKT);
374 }
375 aom_img_free(image);
376
377 // Flush the encoder.
378 bool got_data;
379 do {
380 ASSERT_EQ(aom_codec_encode(&enc, nullptr, 0, 0, 0), AOM_CODEC_OK);
381 got_data = false;
382 iter = nullptr;
383 while ((pkt = aom_codec_get_cx_data(&enc, &iter)) != nullptr) {
384 ASSERT_EQ(pkt->kind, AOM_CODEC_CX_FRAME_PKT);
385 got_data = true;
386 }
387 } while (got_data);
388
389 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
390 }
391
392 // Emulates the WebCodecs VideoEncoder interface.
393 class AV1Encoder {
394 public:
AV1Encoder(int speed)395 explicit AV1Encoder(int speed) : speed_(speed) {}
396 ~AV1Encoder();
397
398 void Configure(unsigned int threads, unsigned int width, unsigned int height,
399 aom_rc_mode end_usage, unsigned int usage);
400 void Encode(bool key_frame);
401
402 private:
403 // Flushes the encoder. Should be called after all the Encode() calls.
404 void Flush();
405
406 const int speed_;
407 bool initialized_ = false;
408 aom_codec_enc_cfg_t cfg_;
409 aom_codec_ctx_t enc_;
410 int frame_index_ = 0;
411 };
412
~AV1Encoder()413 AV1Encoder::~AV1Encoder() {
414 if (initialized_) {
415 Flush();
416 EXPECT_EQ(aom_codec_destroy(&enc_), AOM_CODEC_OK);
417 }
418 }
419
Configure(unsigned int threads,unsigned int width,unsigned int height,aom_rc_mode end_usage,unsigned int usage)420 void AV1Encoder::Configure(unsigned int threads, unsigned int width,
421 unsigned int height, aom_rc_mode end_usage,
422 unsigned int usage) {
423 if (!initialized_) {
424 aom_codec_iface_t *const iface = aom_codec_av1_cx();
425 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg_, usage), AOM_CODEC_OK);
426 cfg_.g_threads = threads;
427 cfg_.g_w = width;
428 cfg_.g_h = height;
429 cfg_.g_forced_max_frame_width = cfg_.g_w;
430 cfg_.g_forced_max_frame_height = cfg_.g_h;
431 cfg_.g_timebase.num = 1;
432 cfg_.g_timebase.den = 1000 * 1000; // microseconds
433 cfg_.g_pass = AOM_RC_ONE_PASS;
434 cfg_.g_lag_in_frames = 0;
435 cfg_.rc_end_usage = end_usage;
436 cfg_.rc_min_quantizer = 2;
437 cfg_.rc_max_quantizer = 58;
438 ASSERT_EQ(aom_codec_enc_init(&enc_, iface, &cfg_, 0), AOM_CODEC_OK);
439 ASSERT_EQ(aom_codec_control(&enc_, AOME_SET_CPUUSED, speed_), AOM_CODEC_OK);
440 initialized_ = true;
441 return;
442 }
443
444 ASSERT_EQ(usage, cfg_.g_usage);
445 cfg_.g_threads = threads;
446 cfg_.g_w = width;
447 cfg_.g_h = height;
448 cfg_.rc_end_usage = end_usage;
449 ASSERT_EQ(aom_codec_enc_config_set(&enc_, &cfg_), AOM_CODEC_OK)
450 << aom_codec_error_detail(&enc_);
451 }
452
Encode(bool key_frame)453 void AV1Encoder::Encode(bool key_frame) {
454 assert(initialized_);
455 // TODO(wtc): Support high bit depths and other YUV formats.
456 aom_image_t *const image =
457 CreateGrayImage(AOM_IMG_FMT_I420, cfg_.g_w, cfg_.g_h);
458 ASSERT_NE(image, nullptr);
459 const aom_enc_frame_flags_t flags = key_frame ? AOM_EFLAG_FORCE_KF : 0;
460 ASSERT_EQ(aom_codec_encode(&enc_, image, frame_index_, 1, flags),
461 AOM_CODEC_OK);
462 frame_index_++;
463 const aom_codec_cx_pkt_t *pkt;
464 aom_codec_iter_t iter = nullptr;
465 while ((pkt = aom_codec_get_cx_data(&enc_, &iter)) != nullptr) {
466 ASSERT_EQ(pkt->kind, AOM_CODEC_CX_FRAME_PKT);
467 if (key_frame) {
468 ASSERT_EQ(pkt->data.frame.flags & AOM_FRAME_IS_KEY, AOM_FRAME_IS_KEY);
469 }
470 }
471 aom_img_free(image);
472 }
473
Flush()474 void AV1Encoder::Flush() {
475 bool got_data;
476 do {
477 ASSERT_EQ(aom_codec_encode(&enc_, nullptr, 0, 0, 0), AOM_CODEC_OK);
478 got_data = false;
479 const aom_codec_cx_pkt_t *pkt;
480 aom_codec_iter_t iter = nullptr;
481 while ((pkt = aom_codec_get_cx_data(&enc_, &iter)) != nullptr) {
482 ASSERT_EQ(pkt->kind, AOM_CODEC_CX_FRAME_PKT);
483 got_data = true;
484 }
485 } while (got_data);
486 }
487
TEST(EncodeAPI,Buganizer314858909)488 TEST(EncodeAPI, Buganizer314858909) {
489 AV1Encoder encoder(7);
490
491 encoder.Configure(6, 1582, 750, AOM_CBR, AOM_USAGE_REALTIME);
492
493 // Encode a frame.
494 encoder.Encode(false);
495
496 encoder.Configure(0, 1582, 23, AOM_CBR, AOM_USAGE_REALTIME);
497
498 // Encode a frame..
499 encoder.Encode(false);
500
501 encoder.Configure(16, 1542, 363, AOM_CBR, AOM_USAGE_REALTIME);
502
503 // Encode a frame..
504 encoder.Encode(false);
505 }
506
507 // Run this test to reproduce the bug in fuzz test: ASSERT: cpi->rec_sse !=
508 // UINT64_MAX in av1_rc_bits_per_mb.
TEST(EncodeAPI,Buganizer310766628)509 TEST(EncodeAPI, Buganizer310766628) {
510 AV1Encoder encoder(7);
511
512 encoder.Configure(16, 759, 383, AOM_CBR, AOM_USAGE_REALTIME);
513
514 // Encode a frame.
515 encoder.Encode(false);
516
517 encoder.Configure(2, 759, 383, AOM_VBR, AOM_USAGE_REALTIME);
518
519 // Encode a frame. This will trigger the assertion failure.
520 encoder.Encode(false);
521 }
522
523 // This test covers a possible use case where the change of frame sizes and
524 // thread numbers happens before and after the first frame coding.
TEST(EncodeAPI,Buganizer310455204)525 TEST(EncodeAPI, Buganizer310455204) {
526 AV1Encoder encoder(7);
527
528 encoder.Configure(0, 1915, 503, AOM_VBR, AOM_USAGE_REALTIME);
529
530 encoder.Configure(4, 1, 1, AOM_VBR, AOM_USAGE_REALTIME);
531
532 encoder.Configure(6, 559, 503, AOM_CBR, AOM_USAGE_REALTIME);
533
534 // Encode a frame.
535 encoder.Encode(false);
536
537 // Increase the number of threads.
538 encoder.Configure(16, 1915, 503, AOM_CBR, AOM_USAGE_REALTIME);
539
540 // Encode a frame.
541 encoder.Encode(false);
542 }
543
544 // Run this test to reproduce the bug in fuzz test: Float-cast-overflow in
545 // av1_rc_bits_per_mb.
TEST(EncodeAPI,Buganizer310457427)546 TEST(EncodeAPI, Buganizer310457427) {
547 AV1Encoder encoder(7);
548
549 encoder.Configure(12, 896, 1076, AOM_CBR, AOM_USAGE_REALTIME);
550
551 encoder.Configure(6, 609, 1076, AOM_VBR, AOM_USAGE_REALTIME);
552
553 // Encode a frame.
554 encoder.Encode(false);
555
556 // Encode a frame. This will trigger the float-cast-overflow bug which was
557 // caused by division by zero.
558 encoder.Encode(false);
559 }
560
TEST(EncodeAPI,PtsSmallerThanInitialPts)561 TEST(EncodeAPI, PtsSmallerThanInitialPts) {
562 // Initialize libaom encoder.
563 aom_codec_iface_t *const iface = aom_codec_av1_cx();
564 aom_codec_ctx_t enc;
565 aom_codec_enc_cfg_t cfg;
566
567 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_REALTIME),
568 AOM_CODEC_OK);
569
570 cfg.g_w = 1280;
571 cfg.g_h = 720;
572 cfg.rc_target_bitrate = 1000;
573
574 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
575
576 // Create input image.
577 aom_image_t *const image =
578 CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
579 ASSERT_NE(image, nullptr);
580
581 // Encode frame.
582 ASSERT_EQ(aom_codec_encode(&enc, image, 12, 1, 0), AOM_CODEC_OK);
583 ASSERT_EQ(aom_codec_encode(&enc, image, 13, 1, 0), AOM_CODEC_OK);
584 // pts (10) is smaller than the initial pts (12).
585 ASSERT_EQ(aom_codec_encode(&enc, image, 10, 1, 0), AOM_CODEC_INVALID_PARAM);
586
587 // Free resources.
588 aom_img_free(image);
589 aom_codec_destroy(&enc);
590 }
591
TEST(EncodeAPI,PtsOrDurationTooBig)592 TEST(EncodeAPI, PtsOrDurationTooBig) {
593 // Initialize libaom encoder.
594 aom_codec_iface_t *const iface = aom_codec_av1_cx();
595 aom_codec_ctx_t enc;
596 aom_codec_enc_cfg_t cfg;
597
598 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_REALTIME),
599 AOM_CODEC_OK);
600
601 cfg.g_w = 1280;
602 cfg.g_h = 720;
603 cfg.rc_target_bitrate = 1000;
604
605 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
606
607 // Create input image.
608 aom_image_t *const image =
609 CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
610 ASSERT_NE(image, nullptr);
611
612 // Encode frame.
613 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
614 // pts, when converted to ticks, is too big.
615 ASSERT_EQ(aom_codec_encode(&enc, image, INT64_MAX / 1000000 + 1, 1, 0),
616 AOM_CODEC_INVALID_PARAM);
617 #if ULONG_MAX > INT64_MAX
618 // duration is too big.
619 ASSERT_EQ(aom_codec_encode(&enc, image, 0, (1ul << 63), 0),
620 AOM_CODEC_INVALID_PARAM);
621 // pts + duration is too big.
622 ASSERT_EQ(aom_codec_encode(&enc, image, 1, INT64_MAX, 0),
623 AOM_CODEC_INVALID_PARAM);
624 #endif
625 // pts + duration, when converted to ticks, is too big.
626 #if ULONG_MAX > INT64_MAX
627 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 0x1c0a0a1a3232, 0),
628 AOM_CODEC_INVALID_PARAM);
629 #endif
630 ASSERT_EQ(aom_codec_encode(&enc, image, INT64_MAX / 1000000, 1, 0),
631 AOM_CODEC_INVALID_PARAM);
632
633 // Free resources.
634 aom_img_free(image);
635 aom_codec_destroy(&enc);
636 }
637
638 // Reproduces https://crbug.com/339877165.
TEST(EncodeAPI,Buganizer339877165)639 TEST(EncodeAPI, Buganizer339877165) {
640 // Initialize libaom encoder.
641 aom_codec_iface_t *const iface = aom_codec_av1_cx();
642 aom_codec_ctx_t enc;
643 aom_codec_enc_cfg_t cfg;
644
645 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_REALTIME),
646 AOM_CODEC_OK);
647
648 cfg.g_w = 2560;
649 cfg.g_h = 1600;
650 cfg.rc_target_bitrate = 231;
651 cfg.rc_end_usage = AOM_CBR;
652 cfg.g_threads = 8;
653
654 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
655
656 // From libaom_av1_encoder.cc in WebRTC.
657 ASSERT_EQ(aom_codec_control(&enc, AOME_SET_CPUUSED, 11), AOM_CODEC_OK);
658 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_CDEF, 1), AOM_CODEC_OK);
659 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_TPL_MODEL, 0),
660 AOM_CODEC_OK);
661 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_DELTAQ_MODE, 0), AOM_CODEC_OK);
662 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_ORDER_HINT, 0),
663 AOM_CODEC_OK);
664 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_AQ_MODE, 3), AOM_CODEC_OK);
665 ASSERT_EQ(aom_codec_control(&enc, AOME_SET_MAX_INTRA_BITRATE_PCT, 300),
666 AOM_CODEC_OK);
667 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_COEFF_COST_UPD_FREQ, 3),
668 AOM_CODEC_OK);
669 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_MODE_COST_UPD_FREQ, 3),
670 AOM_CODEC_OK);
671 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_MV_COST_UPD_FREQ, 3),
672 AOM_CODEC_OK);
673 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_TUNE_CONTENT, AOM_CONTENT_SCREEN),
674 AOM_CODEC_OK);
675 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_PALETTE, 1), AOM_CODEC_OK);
676 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_TILE_ROWS, 1), AOM_CODEC_OK);
677 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_TILE_COLUMNS, 2), AOM_CODEC_OK);
678 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_OBMC, 0), AOM_CODEC_OK);
679 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_NOISE_SENSITIVITY, 0),
680 AOM_CODEC_OK);
681 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_WARPED_MOTION, 0),
682 AOM_CODEC_OK);
683 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_GLOBAL_MOTION, 0),
684 AOM_CODEC_OK);
685 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_REF_FRAME_MVS, 0),
686 AOM_CODEC_OK);
687 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_SUPERBLOCK_SIZE,
688 AOM_SUPERBLOCK_SIZE_DYNAMIC),
689 AOM_CODEC_OK);
690 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_CFL_INTRA, 0),
691 AOM_CODEC_OK);
692 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_SMOOTH_INTRA, 0),
693 AOM_CODEC_OK);
694 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_ANGLE_DELTA, 0),
695 AOM_CODEC_OK);
696 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_FILTER_INTRA, 0),
697 AOM_CODEC_OK);
698 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_INTRA_DEFAULT_TX_ONLY, 1),
699 AOM_CODEC_OK);
700 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_DISABLE_TRELLIS_QUANT, 1),
701 AOM_CODEC_OK);
702 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_DIST_WTD_COMP, 0),
703 AOM_CODEC_OK);
704 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_DIFF_WTD_COMP, 0),
705 AOM_CODEC_OK);
706 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_DUAL_FILTER, 0),
707 AOM_CODEC_OK);
708 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_INTERINTRA_COMP, 0),
709 AOM_CODEC_OK);
710 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_INTERINTRA_WEDGE, 0),
711 AOM_CODEC_OK);
712 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_INTRA_EDGE_FILTER, 0),
713 AOM_CODEC_OK);
714 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_INTRABC, 0), AOM_CODEC_OK);
715 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_MASKED_COMP, 0),
716 AOM_CODEC_OK);
717 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_PAETH_INTRA, 0),
718 AOM_CODEC_OK);
719 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_QM, 0), AOM_CODEC_OK);
720 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_RECT_PARTITIONS, 0),
721 AOM_CODEC_OK);
722 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_RESTORATION, 0),
723 AOM_CODEC_OK);
724 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_SMOOTH_INTERINTRA, 0),
725 AOM_CODEC_OK);
726 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_ENABLE_TX64, 0), AOM_CODEC_OK);
727 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_MAX_REFERENCE_FRAMES, 3),
728 AOM_CODEC_OK);
729 ASSERT_EQ(aom_codec_enc_config_set(&enc, &cfg), AOM_CODEC_OK);
730
731 aom_svc_params_t svc_params = {};
732 svc_params.number_spatial_layers = 2;
733 svc_params.number_temporal_layers = 1;
734 svc_params.max_quantizers[0] = svc_params.max_quantizers[1] = 56;
735 svc_params.min_quantizers[0] = svc_params.min_quantizers[1] = 10;
736 svc_params.scaling_factor_num[0] = svc_params.scaling_factor_num[1] = 1;
737 svc_params.scaling_factor_den[0] = 2;
738 svc_params.scaling_factor_den[1] = 1;
739 svc_params.layer_target_bitrate[0] = cfg.rc_target_bitrate;
740 svc_params.framerate_factor[0] = 1;
741 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_SVC_PARAMS, &svc_params),
742 AOM_CODEC_OK);
743
744 aom_svc_layer_id_t layer_id = {};
745 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_SVC_LAYER_ID, &layer_id),
746 AOM_CODEC_OK);
747
748 aom_svc_ref_frame_config_t ref_frame_config = {};
749 ref_frame_config.refresh[0] = 1;
750 ASSERT_EQ(
751 aom_codec_control(&enc, AV1E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config),
752 AOM_CODEC_OK);
753
754 // Create input image.
755 aom_image_t *const image =
756 CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
757 ASSERT_NE(image, nullptr);
758
759 // Encode layer 0.
760 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
761
762 layer_id.spatial_layer_id = 1;
763 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_SVC_LAYER_ID, &layer_id),
764 AOM_CODEC_OK);
765
766 ref_frame_config.refresh[0] = 0;
767 ASSERT_EQ(
768 aom_codec_control(&enc, AV1E_SET_SVC_REF_FRAME_CONFIG, &ref_frame_config),
769 AOM_CODEC_OK);
770
771 // Encode layer 1.
772 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
773
774 // Free resources.
775 aom_img_free(image);
776 aom_codec_destroy(&enc);
777 }
778
TEST(EncodeAPI,AomediaIssue3509VbrMinSection2Percent)779 TEST(EncodeAPI, AomediaIssue3509VbrMinSection2Percent) {
780 // Initialize libaom encoder.
781 aom_codec_iface_t *const iface = aom_codec_av1_cx();
782 aom_codec_ctx_t enc;
783 aom_codec_enc_cfg_t cfg;
784
785 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_REALTIME),
786 AOM_CODEC_OK);
787
788 cfg.g_w = 1920;
789 cfg.g_h = 1080;
790 cfg.rc_target_bitrate = 1000000;
791 // Set this to more than 1 percent to cause a signed integer overflow in the
792 // multiplication rc->avg_frame_bandwidth * oxcf->rc_cfg.vbrmin_section in
793 // av1_rc_update_framerate() if the multiplication is done in the `int` type.
794 cfg.rc_2pass_vbr_minsection_pct = 2;
795
796 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
797
798 // Create input image.
799 aom_image_t *const image =
800 CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
801 ASSERT_NE(image, nullptr);
802
803 // Encode frame.
804 // `duration` can go as high as 300, but the UBSan error is gone if
805 // `duration` is 301 or higher.
806 ASSERT_EQ(aom_codec_encode(&enc, image, 0, /*duration=*/300, 0),
807 AOM_CODEC_OK);
808
809 // Free resources.
810 aom_img_free(image);
811 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
812 }
813
TEST(EncodeAPI,AomediaIssue3509VbrMinSection101Percent)814 TEST(EncodeAPI, AomediaIssue3509VbrMinSection101Percent) {
815 // Initialize libaom encoder.
816 aom_codec_iface_t *const iface = aom_codec_av1_cx();
817 aom_codec_ctx_t enc;
818 aom_codec_enc_cfg_t cfg;
819
820 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_REALTIME),
821 AOM_CODEC_OK);
822
823 cfg.g_w = 1920;
824 cfg.g_h = 1080;
825 cfg.rc_target_bitrate = 1000000;
826 // Set this to more than 100 percent to cause an error when vbr_min_bits is
827 // cast to `int` in av1_rc_update_framerate() if vbr_min_bits is not clamped
828 // to INT_MAX.
829 cfg.rc_2pass_vbr_minsection_pct = 101;
830
831 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
832
833 // Create input image.
834 aom_image_t *const image =
835 CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
836 ASSERT_NE(image, nullptr);
837
838 // Encode frame.
839 // `duration` can go as high as 300, but the UBSan error is gone if
840 // `duration` is 301 or higher.
841 ASSERT_EQ(aom_codec_encode(&enc, image, 0, /*duration=*/300, 0),
842 AOM_CODEC_OK);
843
844 // Free resources.
845 aom_img_free(image);
846 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
847 }
848
849 class EncodeAPIParameterized
850 : public testing::TestWithParam<std::tuple<
851 /*usage=*/unsigned int, /*speed=*/int, /*aq_mode=*/unsigned int>> {};
852
853 // Encodes two frames at a given usage, speed, and aq_mode setting.
854 // Reproduces b/303023614
TEST_P(EncodeAPIParameterized,HighBDEncoderHighBDFrames)855 TEST_P(EncodeAPIParameterized, HighBDEncoderHighBDFrames) {
856 const unsigned int usage = std::get<0>(GetParam());
857 int speed = std::get<1>(GetParam());
858
859 if (speed == 10 && usage != AOM_USAGE_REALTIME) {
860 speed = 9; // 10 is only allowed in AOM_USAGE_REALTIME
861 }
862
863 aom_codec_iface_t *iface = aom_codec_av1_cx();
864 aom_codec_enc_cfg_t cfg;
865 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, usage), AOM_CODEC_OK);
866 cfg.g_w = 500;
867 cfg.g_h = 400;
868
869 aom_codec_ctx_t enc;
870 aom_codec_err_t init_status =
871 aom_codec_enc_init(&enc, iface, &cfg, AOM_CODEC_USE_HIGHBITDEPTH);
872 #if !CONFIG_AV1_HIGHBITDEPTH
873 ASSERT_EQ(init_status, AOM_CODEC_INCAPABLE);
874 #else
875 ASSERT_EQ(init_status, AOM_CODEC_OK);
876
877 const unsigned int aq_mode = std::get<2>(GetParam());
878
879 ASSERT_EQ(aom_codec_control(&enc, AOME_SET_CPUUSED, speed), AOM_CODEC_OK);
880 ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_AQ_MODE, aq_mode), AOM_CODEC_OK);
881
882 aom_image_t *image =
883 aom_img_alloc(nullptr, AOM_IMG_FMT_I42016, cfg.g_w, cfg.g_h, 0);
884 ASSERT_NE(image, nullptr);
885
886 for (unsigned int i = 0; i < image->d_h; ++i) {
887 Memset16(image->planes[0] + i * image->stride[0], 128, image->d_w);
888 }
889 unsigned int uv_h = (image->d_h + 1) / 2;
890 unsigned int uv_w = (image->d_w + 1) / 2;
891 for (unsigned int i = 0; i < uv_h; ++i) {
892 Memset16(image->planes[1] + i * image->stride[1], 128, uv_w);
893 Memset16(image->planes[2] + i * image->stride[2], 128, uv_w);
894 }
895
896 // Encode two frames.
897 ASSERT_EQ(
898 aom_codec_encode(&enc, image, /*pts=*/0, /*duration=*/1, /*flags=*/0),
899 AOM_CODEC_OK);
900 ASSERT_EQ(
901 aom_codec_encode(&enc, image, /*pts=*/1, /*duration=*/1, /*flags=*/0),
902 AOM_CODEC_OK);
903
904 aom_img_free(image);
905 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
906 #endif
907 }
908
909 const unsigned int kUsages[] = {
910 AOM_USAGE_REALTIME,
911 #if !CONFIG_REALTIME_ONLY
912 AOM_USAGE_GOOD_QUALITY,
913 AOM_USAGE_ALL_INTRA,
914 #endif
915 };
916
917 INSTANTIATE_TEST_SUITE_P(All, EncodeAPIParameterized,
918 testing::Combine(
919 /*usage=*/testing::ValuesIn(kUsages),
920 /*speed=*/testing::Values(6, 7, 10),
921 /*aq_mode=*/testing::Values(0, 1, 2, 3)));
922
923 #if !CONFIG_REALTIME_ONLY
TEST(EncodeAPI,AllIntraMode)924 TEST(EncodeAPI, AllIntraMode) {
925 aom_codec_iface_t *iface = aom_codec_av1_cx();
926 aom_codec_ctx_t enc;
927 aom_codec_enc_cfg_t cfg;
928 EXPECT_EQ(AOM_CODEC_OK,
929 aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA));
930 EXPECT_EQ(AOM_CODEC_OK, aom_codec_enc_init(&enc, iface, &cfg, 0));
931 EXPECT_EQ(AOM_CODEC_OK, aom_codec_destroy(&enc));
932
933 // Set g_lag_in_frames to a nonzero value. This should cause
934 // aom_codec_enc_init() to fail.
935 EXPECT_EQ(AOM_CODEC_OK,
936 aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA));
937 cfg.g_lag_in_frames = 1;
938 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
939
940 // Set kf_max_dist to a nonzero value. This should cause aom_codec_enc_init()
941 // to fail.
942 EXPECT_EQ(AOM_CODEC_OK,
943 aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA));
944 cfg.kf_max_dist = 1;
945 EXPECT_EQ(AOM_CODEC_INVALID_PARAM, aom_codec_enc_init(&enc, iface, &cfg, 0));
946 }
947
TEST(EncodeAPI,AllIntraAndUsePsnr)948 TEST(EncodeAPI, AllIntraAndUsePsnr) {
949 aom_codec_iface_t *iface = aom_codec_av1_cx();
950 aom_codec_enc_cfg_t cfg;
951 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA),
952 AOM_CODEC_OK);
953
954 aom_codec_ctx_t enc;
955 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, AOM_CODEC_USE_PSNR),
956 AOM_CODEC_OK);
957
958 aom_image_t *image = CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
959 ASSERT_NE(image, nullptr);
960
961 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, 0), AOM_CODEC_OK);
962 const aom_codec_cx_pkt_t *pkt;
963 aom_codec_iter_t iter = nullptr;
964 while ((pkt = aom_codec_get_cx_data(&enc, &iter)) != nullptr) {
965 if (pkt->kind != AOM_CODEC_CX_FRAME_PKT) {
966 ASSERT_EQ(pkt->kind, AOM_CODEC_PSNR_PKT);
967 }
968 }
969
970 aom_img_free(image);
971 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
972 }
973
974 // A test that reproduces bug aomedia:3534.
TEST(EncodeAPI,AllIntraAndNoRefLast)975 TEST(EncodeAPI, AllIntraAndNoRefLast) {
976 aom_codec_iface_t *iface = aom_codec_av1_cx();
977 aom_codec_enc_cfg_t cfg;
978 ASSERT_EQ(aom_codec_enc_config_default(iface, &cfg, AOM_USAGE_ALL_INTRA),
979 AOM_CODEC_OK);
980
981 aom_codec_ctx_t enc;
982 ASSERT_EQ(aom_codec_enc_init(&enc, iface, &cfg, 0), AOM_CODEC_OK);
983
984 aom_image_t *image = CreateGrayImage(AOM_IMG_FMT_I420, cfg.g_w, cfg.g_h);
985 ASSERT_NE(image, nullptr);
986
987 ASSERT_EQ(aom_codec_encode(&enc, image, 0, 1, AOM_EFLAG_NO_REF_LAST),
988 AOM_CODEC_OK);
989
990 aom_img_free(image);
991 ASSERT_EQ(aom_codec_destroy(&enc), AOM_CODEC_OK);
992 }
993 #endif // !CONFIG_REALTIME_ONLY
994
995 } // namespace
996