1 /*
2 * Copyright (c) 2019, 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 "gtest/gtest.h"
13
14 #include <cstring>
15 #include <string>
16
17 #include "config/aom_config.h"
18
19 #include "aom/aom_codec.h"
20 #include "aom/aom_image.h"
21 #include "aom/aomcx.h"
22 #include "aom/internal/aom_image_internal.h"
23 #include "aom_scale/yv12config.h"
24 #include "test/codec_factory.h"
25 #include "test/encode_test_driver.h"
26 #include "test/i420_video_source.h"
27 #include "test/util.h"
28 #include "test/video_source.h"
29
30 namespace {
31 const size_t kMetadataPayloadSizeT35 = 24;
32 // 0xB5 stands for the itut t35 metadata country code for the Unites States
33 const uint8_t kMetadataPayloadT35[kMetadataPayloadSizeT35] = {
34 0xB5, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
35 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
36 };
37
38 const size_t kMetadataPayloadSizeMdcv = 24;
39 // Arbitrary content.
40 const uint8_t kMetadataPayloadMdcv[kMetadataPayloadSizeMdcv] = {
41 0x99, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
42 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x99
43 };
44
45 const size_t kMetadataPayloadSizeCll = 4;
46 const uint8_t kMetadataPayloadCll[kMetadataPayloadSizeCll] = { 0xB5, 0x01, 0x02,
47 0x03 };
48
49 const size_t kMetadataObuSizeT35 = 28;
50 const uint8_t kMetadataObuT35[kMetadataObuSizeT35] = {
51 0x2A, 0x1A, 0x04, 0xB5, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
52 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
53 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x80
54 };
55 const size_t kMetadataObuSizeMdcv = 28;
56 const uint8_t kMetadataObuMdcv[kMetadataObuSizeMdcv] = {
57 0x2A, 0x1A, 0x02, 0x99, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
58 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
59 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x99, 0x80
60 };
61 const size_t kMetadataObuSizeCll = 8;
62 const uint8_t kMetadataObuCll[kMetadataObuSizeCll] = { 0x2A, 0x06, 0x01, 0xB5,
63 0x01, 0x02, 0x03, 0x80 };
64
65 #if !CONFIG_REALTIME_ONLY
66 class MetadataEncodeTest
67 : public ::libaom_test::CodecTestWithParam<libaom_test::TestMode>,
68 public ::libaom_test::EncoderTest {
69 protected:
MetadataEncodeTest()70 MetadataEncodeTest() : EncoderTest(GET_PARAM(0)) {}
71
72 ~MetadataEncodeTest() override = default;
73
SetUp()74 void SetUp() override { InitializeConfig(GET_PARAM(1)); }
75
PreEncodeFrameHook(::libaom_test::VideoSource * video,::libaom_test::Encoder * encoder)76 void PreEncodeFrameHook(::libaom_test::VideoSource *video,
77 ::libaom_test::Encoder *encoder) override {
78 if (video->frame() == 0) {
79 encoder->Control(AOME_SET_CPUUSED, 6); // Speed up the test.
80 }
81 aom_image_t *current_frame = video->img();
82 if (!current_frame) {
83 return;
84 }
85 if (current_frame->metadata) aom_img_remove_metadata(current_frame);
86 // invalid: size is 0
87 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
88 kMetadataPayloadT35, 0, AOM_MIF_ANY_FRAME),
89 -1);
90 // invalid: data is nullptr
91 ASSERT_EQ(
92 aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35, nullptr,
93 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME),
94 -1);
95 // invalid: size is 0 and data is nullptr
96 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
97 nullptr, 0, AOM_MIF_ANY_FRAME),
98 -1);
99 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
100 kMetadataPayloadT35, kMetadataPayloadSizeT35,
101 AOM_MIF_ANY_FRAME),
102 0);
103
104 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_HDR_MDCV,
105 kMetadataPayloadMdcv,
106 kMetadataPayloadSizeMdcv, AOM_MIF_KEY_FRAME),
107 0);
108
109 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_HDR_CLL,
110 kMetadataPayloadCll, kMetadataPayloadSizeCll,
111 AOM_MIF_KEY_FRAME),
112 0);
113 }
114
FramePktHook(const aom_codec_cx_pkt_t * pkt)115 void FramePktHook(const aom_codec_cx_pkt_t *pkt) override {
116 if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
117 const bool is_key_frame = (pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0;
118
119 const std::string bitstream(
120 static_cast<const char *>(pkt->data.frame.buf), pkt->data.frame.sz);
121 // Look for valid metadatas in bitstream.
122 const bool itut_t35_metadata_found =
123 bitstream.find(reinterpret_cast<const char *>(kMetadataObuT35), 0,
124 kMetadataObuSizeT35) != std::string::npos;
125 const bool hdr_mdcv_metadata_found =
126 bitstream.find(reinterpret_cast<const char *>(kMetadataObuMdcv), 0,
127 kMetadataObuSizeMdcv) != std::string::npos;
128 const bool hdr_cll_metadata_found =
129 bitstream.find(reinterpret_cast<const char *>(kMetadataObuCll), 0,
130 kMetadataObuSizeCll) != std::string::npos;
131
132 EXPECT_TRUE(itut_t35_metadata_found);
133 EXPECT_EQ(hdr_mdcv_metadata_found, is_key_frame);
134 EXPECT_EQ(hdr_cll_metadata_found, is_key_frame);
135 }
136 }
137
DecompressedFrameHook(const aom_image_t & img,aom_codec_pts_t)138 void DecompressedFrameHook(const aom_image_t &img,
139 aom_codec_pts_t /*pts*/) override {
140 const bool is_key_frame =
141 (num_decompressed_frames_ % cfg_.kf_max_dist) == 0;
142 ++num_decompressed_frames_;
143
144 ASSERT_NE(img.metadata, nullptr);
145
146 ASSERT_EQ(img.metadata->sz, is_key_frame ? 3 : 1);
147
148 ASSERT_EQ(OBU_METADATA_TYPE_ITUT_T35,
149 img.metadata->metadata_array[0]->type);
150 ASSERT_EQ(kMetadataPayloadSizeT35, img.metadata->metadata_array[0]->sz);
151 EXPECT_EQ(
152 memcmp(kMetadataPayloadT35, img.metadata->metadata_array[0]->payload,
153 kMetadataPayloadSizeT35),
154 0);
155
156 if (is_key_frame) {
157 ASSERT_EQ(OBU_METADATA_TYPE_HDR_MDCV,
158 img.metadata->metadata_array[1]->type);
159 ASSERT_EQ(kMetadataPayloadSizeMdcv, img.metadata->metadata_array[1]->sz);
160 EXPECT_EQ(
161 memcmp(kMetadataPayloadMdcv, img.metadata->metadata_array[1]->payload,
162 kMetadataPayloadSizeMdcv),
163 0);
164
165 ASSERT_EQ(OBU_METADATA_TYPE_HDR_CLL,
166 img.metadata->metadata_array[2]->type);
167 ASSERT_EQ(kMetadataPayloadSizeCll, img.metadata->metadata_array[2]->sz);
168 EXPECT_EQ(
169 memcmp(kMetadataPayloadCll, img.metadata->metadata_array[2]->payload,
170 kMetadataPayloadSizeCll),
171 0);
172 }
173 }
174
175 private:
176 int num_decompressed_frames_ = 0;
177 };
178
TEST_P(MetadataEncodeTest,TestMetadataEncoding)179 TEST_P(MetadataEncodeTest, TestMetadataEncoding) {
180 ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
181 30, 1, 0, 10);
182 init_flags_ = AOM_CODEC_USE_PSNR;
183
184 cfg_.g_w = 352;
185 cfg_.g_h = 288;
186
187 cfg_.rc_buf_initial_sz = 500;
188 cfg_.rc_buf_optimal_sz = 600;
189 cfg_.rc_buf_sz = 1000;
190 cfg_.rc_min_quantizer = 2;
191 cfg_.rc_max_quantizer = 56;
192 cfg_.rc_undershoot_pct = 50;
193 cfg_.rc_overshoot_pct = 50;
194 cfg_.kf_mode = AOM_KF_AUTO;
195 cfg_.g_lag_in_frames = 1;
196 cfg_.kf_min_dist = cfg_.kf_max_dist = 5;
197 // Run at low bitrate.
198 cfg_.rc_target_bitrate = 40;
199
200 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
201 }
202
203 AV1_INSTANTIATE_TEST_SUITE(MetadataEncodeTest,
204 ::testing::Values(::libaom_test::kOnePassGood));
205 #endif // !CONFIG_REALTIME_ONLY
206
207 class MetadataMultilayerEncodeTest
208 : public ::libaom_test::CodecTestWithParam<libaom_test::TestMode>,
209 public ::libaom_test::EncoderTest {
210 protected:
MetadataMultilayerEncodeTest()211 MetadataMultilayerEncodeTest() : EncoderTest(GET_PARAM(0)) {}
212
213 ~MetadataMultilayerEncodeTest() override = default;
214
215 static const int kNumSpatialLayers = 3;
216
SetUp()217 void SetUp() override { InitializeConfig(GET_PARAM(1)); }
218
GetNumSpatialLayers()219 int GetNumSpatialLayers() override { return kNumSpatialLayers; }
220
PreEncodeFrameHook(::libaom_test::VideoSource * video,::libaom_test::Encoder * encoder)221 void PreEncodeFrameHook(::libaom_test::VideoSource *video,
222 ::libaom_test::Encoder *encoder) override {
223 aom_image_t *current_frame = video->img();
224 if (!current_frame) {
225 return;
226 }
227
228 // One-time initialization only done on the first frame.
229 if (num_encoded_frames_ == 0) {
230 encoder->Control(AOME_SET_CPUUSED, 6); // Speed up the test.
231 aom_svc_params_t svc_params = GetSvcParams();
232 encoder->Control(AV1E_SET_SVC_PARAMS, &svc_params);
233 }
234
235 const int spatial_layer_id = num_encoded_frames_ % 3;
236 aom_svc_layer_id_t layer_id = { spatial_layer_id, 0 };
237 encoder->Control(AV1E_SET_SVC_LAYER_ID, &layer_id);
238
239 if (current_frame->metadata) aom_img_remove_metadata(current_frame);
240
241 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
242 kMetadataPayloadT35, kMetadataPayloadSizeT35,
243 AOM_MIF_ANY_FRAME),
244 0);
245
246 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_HDR_MDCV,
247 kMetadataPayloadMdcv,
248 kMetadataPayloadSizeMdcv, AOM_MIF_KEY_FRAME),
249 0);
250
251 ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_HDR_CLL,
252 kMetadataPayloadCll, kMetadataPayloadSizeCll,
253 AOM_MIF_KEY_FRAME),
254 0);
255
256 num_encoded_frames_++;
257 }
258
FramePktHook(const aom_codec_cx_pkt_t * pkt)259 void FramePktHook(const aom_codec_cx_pkt_t *pkt) override {
260 if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
261 const bool is_key_frame = (pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0;
262
263 const std::string bitstream(
264 static_cast<const char *>(pkt->data.frame.buf), pkt->data.frame.sz);
265
266 // Look for valid metadatas in bitstream.
267 const bool itut_t35_metadata_found =
268 bitstream.find(reinterpret_cast<const char *>(kMetadataObuT35), 0,
269 kMetadataObuSizeT35) != std::string::npos;
270 const bool hdr_mdcv_metadata_found =
271 bitstream.find(reinterpret_cast<const char *>(kMetadataObuMdcv), 0,
272 kMetadataObuSizeMdcv) != std::string::npos;
273 const bool hdr_cll_metadata_found =
274 bitstream.find(reinterpret_cast<const char *>(kMetadataObuCll), 0,
275 kMetadataObuSizeCll) != std::string::npos;
276
277 EXPECT_TRUE(itut_t35_metadata_found);
278 EXPECT_EQ(hdr_mdcv_metadata_found, is_key_frame);
279 EXPECT_EQ(hdr_cll_metadata_found, is_key_frame);
280 }
281 }
282
DecompressedFrameHook(const aom_image_t & img,aom_codec_pts_t)283 void DecompressedFrameHook(const aom_image_t &img,
284 aom_codec_pts_t /*pts*/) override {
285 const bool is_key_frame = (num_decompressed_frames_ == 0);
286
287 ++num_decompressed_frames_;
288
289 ASSERT_NE(img.metadata, nullptr);
290
291 ASSERT_EQ(img.metadata->sz, is_key_frame ? 3 : 1);
292
293 ASSERT_EQ(OBU_METADATA_TYPE_ITUT_T35,
294 img.metadata->metadata_array[0]->type);
295 ASSERT_EQ(kMetadataPayloadSizeT35, img.metadata->metadata_array[0]->sz);
296 EXPECT_EQ(
297 memcmp(kMetadataPayloadT35, img.metadata->metadata_array[0]->payload,
298 kMetadataPayloadSizeT35),
299 0);
300
301 if (is_key_frame) {
302 ASSERT_EQ(OBU_METADATA_TYPE_HDR_MDCV,
303 img.metadata->metadata_array[1]->type);
304 ASSERT_EQ(kMetadataPayloadSizeMdcv, img.metadata->metadata_array[1]->sz);
305 EXPECT_EQ(
306 memcmp(kMetadataPayloadMdcv, img.metadata->metadata_array[1]->payload,
307 kMetadataPayloadSizeMdcv),
308 0);
309
310 ASSERT_EQ(OBU_METADATA_TYPE_HDR_CLL,
311 img.metadata->metadata_array[2]->type);
312 ASSERT_EQ(kMetadataPayloadSizeCll, img.metadata->metadata_array[2]->sz);
313 EXPECT_EQ(
314 memcmp(kMetadataPayloadCll, img.metadata->metadata_array[2]->payload,
315 kMetadataPayloadSizeCll),
316 0);
317 }
318 }
319
320 private:
GetSvcParams()321 aom_svc_params_t GetSvcParams() {
322 aom_svc_params_t svc_params = {};
323 svc_params.number_spatial_layers = kNumSpatialLayers;
324 svc_params.number_temporal_layers = 1;
325 for (int i = 0; i < kNumSpatialLayers; ++i) {
326 svc_params.max_quantizers[i] = 60;
327 svc_params.min_quantizers[i] = 2;
328 }
329
330 svc_params.framerate_factor[0] = 1;
331
332 svc_params.layer_target_bitrate[0] = 30 * cfg_.rc_target_bitrate / 100;
333 svc_params.layer_target_bitrate[1] = 60 * cfg_.rc_target_bitrate / 100;
334 svc_params.layer_target_bitrate[2] = cfg_.rc_target_bitrate;
335
336 svc_params.scaling_factor_num[0] = 1;
337 svc_params.scaling_factor_den[0] = 4;
338 svc_params.scaling_factor_num[1] = 1;
339 svc_params.scaling_factor_den[1] = 2;
340 svc_params.scaling_factor_num[2] = 1;
341 svc_params.scaling_factor_den[2] = 1;
342
343 return svc_params;
344 }
345
346 int num_encoded_frames_ = 0;
347 int num_decompressed_frames_ = 0;
348 };
349
350 } // namespace
351
TEST_P(MetadataMultilayerEncodeTest,Test)352 TEST_P(MetadataMultilayerEncodeTest, Test) {
353 cfg_.rc_buf_initial_sz = 500;
354 cfg_.rc_buf_optimal_sz = 500;
355 cfg_.rc_buf_sz = 1000;
356 cfg_.g_lag_in_frames = 0;
357 cfg_.g_error_resilient = 0;
358 cfg_.rc_target_bitrate = 1200;
359
360 ::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
361 30, 1, 0, /*limit=*/10);
362 ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
363 }
364
365 AV1_INSTANTIATE_TEST_SUITE(MetadataMultilayerEncodeTest,
366 ::testing::Values(::libaom_test::kRealTime));
367
TEST(MetadataTest,MetadataAllocation)368 TEST(MetadataTest, MetadataAllocation) {
369 aom_metadata_t *metadata =
370 aom_img_metadata_alloc(OBU_METADATA_TYPE_ITUT_T35, kMetadataPayloadT35,
371 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME);
372 ASSERT_NE(metadata, nullptr);
373 aom_img_metadata_free(metadata);
374 }
375
TEST(MetadataTest,MetadataArrayAllocation)376 TEST(MetadataTest, MetadataArrayAllocation) {
377 aom_metadata_array_t *metadata_array = aom_img_metadata_array_alloc(2);
378 ASSERT_NE(metadata_array, nullptr);
379
380 metadata_array->metadata_array[0] =
381 aom_img_metadata_alloc(OBU_METADATA_TYPE_ITUT_T35, kMetadataPayloadT35,
382 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME);
383 metadata_array->metadata_array[1] =
384 aom_img_metadata_alloc(OBU_METADATA_TYPE_ITUT_T35, kMetadataPayloadT35,
385 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME);
386
387 aom_img_metadata_array_free(metadata_array);
388 }
389
TEST(MetadataTest,AddMetadataToImage)390 TEST(MetadataTest, AddMetadataToImage) {
391 aom_image_t image;
392 image.metadata = nullptr;
393
394 ASSERT_EQ(aom_img_add_metadata(&image, OBU_METADATA_TYPE_ITUT_T35,
395 kMetadataPayloadT35, kMetadataPayloadSizeT35,
396 AOM_MIF_ANY_FRAME),
397 0);
398 aom_img_metadata_array_free(image.metadata);
399 EXPECT_EQ(aom_img_add_metadata(nullptr, OBU_METADATA_TYPE_ITUT_T35,
400 kMetadataPayloadT35, kMetadataPayloadSizeT35,
401 AOM_MIF_ANY_FRAME),
402 -1);
403 }
404
TEST(MetadataTest,RemoveMetadataFromImage)405 TEST(MetadataTest, RemoveMetadataFromImage) {
406 aom_image_t image;
407 image.metadata = nullptr;
408
409 ASSERT_EQ(aom_img_add_metadata(&image, OBU_METADATA_TYPE_ITUT_T35,
410 kMetadataPayloadT35, kMetadataPayloadSizeT35,
411 AOM_MIF_ANY_FRAME),
412 0);
413 aom_img_remove_metadata(&image);
414 aom_img_remove_metadata(nullptr);
415 }
416
TEST(MetadataTest,CopyMetadataToFrameBuffer)417 TEST(MetadataTest, CopyMetadataToFrameBuffer) {
418 YV12_BUFFER_CONFIG yvBuf;
419 yvBuf.metadata = nullptr;
420
421 aom_metadata_array_t *metadata_array = aom_img_metadata_array_alloc(1);
422 ASSERT_NE(metadata_array, nullptr);
423
424 metadata_array->metadata_array[0] =
425 aom_img_metadata_alloc(OBU_METADATA_TYPE_ITUT_T35, kMetadataPayloadT35,
426 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME);
427
428 // Metadata_array
429 int status = aom_copy_metadata_to_frame_buffer(&yvBuf, metadata_array);
430 EXPECT_EQ(status, 0);
431 status = aom_copy_metadata_to_frame_buffer(nullptr, metadata_array);
432 EXPECT_EQ(status, -1);
433 aom_img_metadata_array_free(metadata_array);
434
435 // Metadata_array_2
436 aom_metadata_array_t *metadata_array_2 = aom_img_metadata_array_alloc(0);
437 ASSERT_NE(metadata_array_2, nullptr);
438 status = aom_copy_metadata_to_frame_buffer(&yvBuf, metadata_array_2);
439 EXPECT_EQ(status, -1);
440 aom_img_metadata_array_free(metadata_array_2);
441
442 // YV12_BUFFER_CONFIG
443 status = aom_copy_metadata_to_frame_buffer(&yvBuf, nullptr);
444 EXPECT_EQ(status, -1);
445 aom_remove_metadata_from_frame_buffer(&yvBuf);
446 aom_remove_metadata_from_frame_buffer(nullptr);
447 }
448
TEST(MetadataTest,GetMetadataFromImage)449 TEST(MetadataTest, GetMetadataFromImage) {
450 aom_image_t image;
451 image.metadata = nullptr;
452
453 ASSERT_EQ(aom_img_add_metadata(&image, OBU_METADATA_TYPE_ITUT_T35,
454 kMetadataPayloadT35, kMetadataPayloadSizeT35,
455 AOM_MIF_ANY_FRAME),
456 0);
457
458 EXPECT_EQ(aom_img_get_metadata(nullptr, 0), nullptr);
459 EXPECT_EQ(aom_img_get_metadata(&image, 1u), nullptr);
460 EXPECT_EQ(aom_img_get_metadata(&image, 10u), nullptr);
461
462 const aom_metadata_t *metadata = aom_img_get_metadata(&image, 0);
463 ASSERT_NE(metadata, nullptr);
464 ASSERT_EQ(metadata->sz, kMetadataPayloadSizeT35);
465 EXPECT_EQ(
466 memcmp(kMetadataPayloadT35, metadata->payload, kMetadataPayloadSizeT35),
467 0);
468
469 aom_img_metadata_array_free(image.metadata);
470 }
471
TEST(MetadataTest,ReadMetadatasFromImage)472 TEST(MetadataTest, ReadMetadatasFromImage) {
473 aom_image_t image;
474 image.metadata = nullptr;
475
476 uint32_t types[3];
477 types[0] = OBU_METADATA_TYPE_ITUT_T35;
478 types[1] = OBU_METADATA_TYPE_HDR_CLL;
479 types[2] = OBU_METADATA_TYPE_HDR_MDCV;
480
481 ASSERT_EQ(aom_img_add_metadata(&image, types[0], kMetadataPayloadT35,
482 kMetadataPayloadSizeT35, AOM_MIF_ANY_FRAME),
483 0);
484 ASSERT_EQ(aom_img_add_metadata(&image, types[1], kMetadataPayloadT35,
485 kMetadataPayloadSizeT35, AOM_MIF_KEY_FRAME),
486 0);
487 ASSERT_EQ(aom_img_add_metadata(&image, types[2], kMetadataPayloadT35,
488 kMetadataPayloadSizeT35, AOM_MIF_KEY_FRAME),
489 0);
490
491 size_t number_metadata = aom_img_num_metadata(&image);
492 ASSERT_EQ(number_metadata, 3u);
493 for (size_t i = 0; i < number_metadata; ++i) {
494 const aom_metadata_t *metadata = aom_img_get_metadata(&image, i);
495 ASSERT_NE(metadata, nullptr);
496 ASSERT_EQ(metadata->type, types[i]);
497 ASSERT_EQ(metadata->sz, kMetadataPayloadSizeT35);
498 EXPECT_EQ(
499 memcmp(kMetadataPayloadT35, metadata->payload, kMetadataPayloadSizeT35),
500 0);
501 }
502 aom_img_metadata_array_free(image.metadata);
503 }
504