1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17 #include "media_errors.h"
18 #include "avmetadata_unit_test.h"
19
20 using namespace std;
21 using namespace OHOS;
22 using namespace OHOS::Media;
23 using namespace testing::ext;
24 using namespace AVMetadataTestParam;
25
26 namespace OHOS {
27 namespace Media {
28
29 /**
30 Function: compare metadata
31 Description: test for metadata
32 Input: uri, expected MetaData
33 Return: null
34 */
CheckMeta(std::string uri,std::unordered_map<int32_t,std::string> expectMeta)35 void AVMetadataUnitTest::CheckMeta(std::string uri, std::unordered_map<int32_t, std::string> expectMeta)
36 {
37 auto helper = AVMetadataHelperServer::Create();
38
39 std::string file = uri.substr(strlen("file://"));
40 int32_t fileDes = open(file.c_str(), O_RDONLY);
41 ASSERT_GT(fileDes, -1);
42
43 struct stat64 st;
44 ASSERT_EQ(fstat64(fileDes, &st), 0);
45 int64_t len = static_cast<int64_t>(st.st_size);
46 int32_t ret = helper->SetSource(fileDes, 0, len, 0);
47 ASSERT_EQ(ret, 0);
48
49 for (auto &item : expectMeta) {
50 std::string value = helper->ResolveMetadata(item.first);
51 EXPECT_EQ(AVMetadataTestBase::GetInstance().CompareMetadata(item.first, value, item.second), true);
52 }
53 auto resultMetas = helper->ResolveMetadata();
54 EXPECT_EQ(AVMetadataTestBase::GetInstance().CompareMetadata(resultMetas, expectMeta), true);
55 helper->Release();
56 }
57
58 /**
59 * @tc.number : GetThumbnail
60 * @tc.name : Get Thumbnail
61 * @tc.desc : Get THUMBNAIL Function case
62 */
GetThumbnail(const std::string uri)63 void AVMetadataUnitTest::GetThumbnail(const std::string uri)
64 {
65 auto helper = AVMetadataHelperServer::Create();
66 ASSERT_NE(nullptr, helper);
67 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
68
69 OutputConfiguration param = {-1, -1, PixelFormat::RGB_565};
70 int64_t timeUs = 0;
71 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
72 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
73 ASSERT_NE(nullptr, frame);
74 timeUs = 5000000; // 5000000us
75 queryOption = AVMetadataQueryOption::AV_META_QUERY_PREVIOUS_SYNC;
76 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
77 ASSERT_NE(nullptr, frame);
78
79 param = {-1, -1, PixelFormat::RGB_888};
80 queryOption = AVMetadataQueryOption::AV_META_QUERY_CLOSEST_SYNC;
81 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
82 ASSERT_NE(nullptr, frame);
83
84 timeUs = 0;
85 queryOption = AVMetadataQueryOption::AV_META_QUERY_CLOSEST;
86 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
87 ASSERT_NE(nullptr, frame);
88 helper->Release();
89 }
90
91 /**
92 * @tc.number : ResolveMetadata_Format_MP4_0100
93 * @tc.name : 01.MP4 format Get MetaData(H264+AAC)
94 * @tc.desc : test ResolveMetadata
95 */
96 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0100, TestSize.Level0)
97 {
98 EXPECT_META[AV_KEY_DATE_TIME] = "2022-05-30 06:10:43";
99 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
100 std::string("H264_AAC.mp4");
101 CheckMeta(uri, EXPECT_META);
102 }
103
104 /**
105 * @tc.number : ResolveMetadata_Format_MP4_0200
106 * @tc.name : 02.MP4 format Get MetaData(H264+MP3)
107 * @tc.desc : test ResolveMetadata
108 */
109 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0200, Function | MediumTest | Level0)
110 {
111 EXPECT_META[AV_KEY_DATE_TIME] = "2022";
112 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
113 std::string("/H264_MP3.mp4");
114 CheckMeta(uri, EXPECT_META);
115 }
116
117 /**
118 * @tc.number : ResolveMetadata_Format_MP4_0500
119 * @tc.name : 05.MP4 format Get MetaData(MPEG4+AAC)
120 * @tc.desc : test ResolveMetadata
121 */
122 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0500, Function | MediumTest | Level0)
123 {
124 EXPECT_META[AV_KEY_DATE_TIME] = "2022-05-29 22:46:43";
125 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
126 std::string("/MPEG4_AAC.mp4");
127 CheckMeta(uri, EXPECT_META);
128 }
129
130 /**
131 * @tc.number : ResolveMetadata_Format_MP4_0600
132 * @tc.name : 06.MP4 format Get MetaData(MPEG4+MP3)
133 * @tc.desc : test ResolveMetadata
134 */
135 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0600, Function | MediumTest | Level0)
136 {
137 EXPECT_META[AV_KEY_DATE_TIME] = "2022-05";
138 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
139 std::string("/MPEG4_MP3.mp4");
140 CheckMeta(uri, EXPECT_META);
141 }
142
143 /**
144 * @tc.number : ResolveMetadata_Format_MP4_0700
145 * @tc.name : 07.MP4 format Get MetaData(HDR)
146 * @tc.desc : test ResolveMetadata
147 */
148 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0700, Function | MediumTest | Level0)
149 {
150 std::unordered_map<int32_t, std::string> expectMeta;
151 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
152 std::string("/HDR.mp4");
153 #ifndef CHECKING_VIDEO_IS_HDR_VIVID
154 expectMeta.insert(std::make_pair(AV_KEY_VIDEO_IS_HDR_VIVID, ""));
155 #else
156 expectMeta.insert(std::make_pair(AV_KEY_VIDEO_IS_HDR_VIVID, "yes"));
157 #endif
158 CheckMeta(uri, expectMeta);
159 }
160
161 /**
162 * @tc.number : ResolveMetadata_Format_MP4_0800
163 * @tc.name : 08.MP4 format Get MetaData(SDR)
164 * @tc.desc : test ResolveMetadata
165 */
166 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0800, Function | MediumTest | Level0)
167 {
168 std::unordered_map<int32_t, std::string> expectMeta;
169 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
170 std::string("/SDR.mp4");
171 expectMeta.insert(std::make_pair(AV_KEY_VIDEO_IS_HDR_VIVID, ""));
172 CheckMeta(uri, expectMeta);
173 }
174
175 /**
176 * @tc.number : ResolveMetadata_Format_M4A_0100
177 * @tc.name : 01.M4A format Get MetaData
178 * @tc.desc : test ResolveMetadata
179 */
180 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_M4A_0100, Function | MediumTest | Level0)
181 {
182 std::unordered_map<int32_t, std::string> expectMeta = {
183 {AV_KEY_ALBUM, "media"},
184 {AV_KEY_ALBUM_ARTIST, "media_test"},
185 {AV_KEY_ARTIST, "元数据测试"},
186 {AV_KEY_AUTHOR, ""},
187 {AV_KEY_COMPOSER, "测试"},
188 {AV_KEY_DURATION, "219562"},
189 {AV_KEY_GENRE, "Lyrical"},
190 {AV_KEY_HAS_AUDIO, "yes"},
191 {AV_KEY_HAS_VIDEO, ""},
192 {AV_KEY_MIME_TYPE, "audio/mp4"},
193 {AV_KEY_NUM_TRACKS, "1"},
194 {AV_KEY_SAMPLE_RATE, "48000"},
195 {AV_KEY_TITLE, "test"},
196 {AV_KEY_VIDEO_HEIGHT, ""},
197 {AV_KEY_VIDEO_WIDTH, ""},
198 {AV_KEY_DATE_TIME, "2015-11-23"},
199 };
200 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
201 std::string("/aac_48000Hz_70kbs_mono.m4a");
202 CheckMeta(uri, expectMeta);
203 }
204
205 /**
206 * @tc.number : ResolveMetadata_Format_MP3_0100
207 * @tc.name : 01.MP3 format Get MetaData
208 * @tc.desc : test ResolveMetadata
209 */
210 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP3_0100, Function | MediumTest | Level0)
211 {
212 std::unordered_map<int32_t, std::string> expectMeta = {
213 {AV_KEY_ALBUM, "media"},
214 {AV_KEY_ALBUM_ARTIST, "media_test"},
215 {AV_KEY_ARTIST, "元数据测试"},
216 {AV_KEY_AUTHOR, "media"},
217 {AV_KEY_COMPOSER, "测试"},
218 {AV_KEY_DURATION, "219600"},
219 {AV_KEY_GENRE, "Lyrical"},
220 {AV_KEY_HAS_AUDIO, "yes"},
221 {AV_KEY_HAS_VIDEO, ""},
222 {AV_KEY_MIME_TYPE, "audio/mpeg"},
223 {AV_KEY_NUM_TRACKS, "1"},
224 {AV_KEY_SAMPLE_RATE, "48000"},
225 {AV_KEY_TITLE, "test"},
226 {AV_KEY_VIDEO_HEIGHT, ""},
227 {AV_KEY_VIDEO_WIDTH, ""},
228 {AV_KEY_DATE_TIME, "2022-05"},
229 };
230 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
231 std::string("/mp3_48000Hz_64kbs_mono.mp3");
232 CheckMeta(uri, expectMeta);
233 }
234
235 /**
236 * @tc.number : ResolveMetadata_Format_AAC_0100
237 * @tc.name : 01.AAC format Get MetaData
238 * @tc.desc : test ResolveMetadata
239 */
240 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_AAC_0100, Function | MediumTest | Level0)
241 {
242 std::unordered_map<int32_t, std::string> expectMeta = {
243 {AV_KEY_ALBUM, ""},
244 {AV_KEY_ALBUM_ARTIST, ""},
245 {AV_KEY_ARTIST, ""},
246 {AV_KEY_AUTHOR, ""},
247 {AV_KEY_COMPOSER, ""},
248 {AV_KEY_DURATION, "219780"},
249 {AV_KEY_GENRE, ""},
250 {AV_KEY_HAS_AUDIO, "yes"},
251 {AV_KEY_HAS_VIDEO, ""},
252 {AV_KEY_MIME_TYPE, "audio/aac-adts"},
253 {AV_KEY_NUM_TRACKS, "1"},
254 {AV_KEY_SAMPLE_RATE, "44100"},
255 {AV_KEY_TITLE, ""},
256 {AV_KEY_VIDEO_HEIGHT, ""},
257 {AV_KEY_VIDEO_WIDTH, ""},
258 };
259 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
260 std::string("/aac_44100Hz_143kbs_stereo.aac");
261 CheckMeta(uri, expectMeta);
262 }
263
264 /**
265 * @tc.number : ResolveMetadata_Format_WAV_0100
266 * @tc.name : 01.WAV format Get MetaData
267 * @tc.desc : test ResolveMetadata
268 */
269 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_WAV_0100, Function | MediumTest | Level0)
270 {
271 std::unordered_map<int32_t, std::string> expectMeta = {
272 {AV_KEY_ALBUM, "media"},
273 {AV_KEY_ARTIST, "元数据测试"},
274 {AV_KEY_ALBUM_ARTIST, ""},
275 {AV_KEY_COMPOSER, ""},
276 {AV_KEY_AUTHOR, ""},
277 {AV_KEY_GENRE, "Lyrical"},
278 {AV_KEY_DURATION, "5460"},
279 {AV_KEY_HAS_VIDEO, ""},
280 {AV_KEY_HAS_AUDIO, "yes"},
281 {AV_KEY_MIME_TYPE, "audio/wav"},
282 {AV_KEY_SAMPLE_RATE, "48000"},
283 {AV_KEY_NUM_TRACKS, "1"},
284 {AV_KEY_DATE_TIME, "2022-05-29 22:46:43"},
285 {AV_KEY_TITLE, "test"},
286 {AV_KEY_VIDEO_WIDTH, ""},
287 {AV_KEY_VIDEO_HEIGHT, ""},
288 };
289 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
290 std::string("/pcm_s16le_48000Hz_768kbs_mono.wav");
291 CheckMeta(uri, expectMeta);
292 }
293
294 /**
295 * @tc.number : ResolveMetadata_Format_WAV_0200
296 * @tc.name : 01.WAV format Get MetaData
297 * @tc.desc : test ResolveMetadata
298 */
299 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_WAV_0200, Function | MediumTest | Level0)
300 {
301 std::unordered_map<int32_t, std::string> expectMeta = {
302 {AV_KEY_ALBUM, "media"},
303 {AV_KEY_ALBUM_ARTIST, ""},
304 {AV_KEY_ARTIST, "元数据测试"},
305 {AV_KEY_AUTHOR, ""},
306 {AV_KEY_COMPOSER, ""},
307 {AV_KEY_DURATION, "5460"},
308 {AV_KEY_GENRE, "Lyrical"},
309 {AV_KEY_HAS_AUDIO, "yes"},
310 {AV_KEY_HAS_VIDEO, ""},
311 {AV_KEY_MIME_TYPE, "audio/wav"},
312 {AV_KEY_NUM_TRACKS, "1"},
313 {AV_KEY_SAMPLE_RATE, "48000"},
314 {AV_KEY_TITLE, "test"},
315 {AV_KEY_VIDEO_HEIGHT, ""},
316 {AV_KEY_VIDEO_WIDTH, ""},
317 {AV_KEY_DATE_TIME, "2022"},
318 };
319 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
320 std::string("/pcm_s16le_48000Hz_768kbs_mono_date.wav");
321 CheckMeta(uri, expectMeta);
322 }
323
324 /**
325 * @tc.number : FetchArtPicture_Format_MP3_0100
326 * @tc.name : Get SURFACE FROM MP3_SURFACE.mp3
327 * @tc.desc : Get SURFACE FROM MP3_SURFACE.mp3
328 */
329 HWTEST_F(AVMetadataUnitTest, FetchArtPicture_Format_MP3_0100, Function | MediumTest | Level0)
330 {
331 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
332 std::string("MP3_SURFACE.mp3");
333
334 auto helper = AVMetadataHelperServer::Create();
335 ASSERT_NE(nullptr, helper);
336 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
337 std::shared_ptr<AVSharedMemory> frame = helper->FetchArtPicture();
338 ASSERT_EQ(51.3046875*1024, frame->GetSize());
339 }
340
341 /**
342 * @tc.number : FetchArtPicture_Format_MP3_0200
343 * @tc.name : Get ArtPicture FROM H264_AAC.mp4
344 * @tc.desc : Get ArtPicture FROM H264_AAC.mp4
345 */
346 HWTEST_F(AVMetadataUnitTest, FetchArtPicture_Format_MP3_0200, Function | MediumTest | Level0)
347 {
348 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
349 std::string("H264_AAC.mp4");
350
351 auto helper = AVMetadataHelperServer::Create();
352 ASSERT_NE(nullptr, helper);
353 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
354 std::shared_ptr<AVSharedMemory> frame = helper->FetchArtPicture();
355 ASSERT_EQ(nullptr, frame);
356 }
357
358 /**
359 * @tc.number : FetchFrameAtTime_Resolution_0100
360 * @tc.name : Resolution 170x170
361 * @tc.desc : Get THUMBNAIL
362 */
363 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0100, TestSize.Level0)
364 {
365 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
366 std::string("out_170_170.mp4");
367 GetThumbnail(uri);
368 }
369
370 /**
371 * @tc.number : FetchFrameAtTime_Resolution_0200
372 * @tc.name : Resolution 480x320
373 * @tc.desc : Get THUMBNAIL
374 */
375 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0200, TestSize.Level0)
376 {
377 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
378 std::string("out_480_320.mp4");
379 GetThumbnail(uri);
380 }
381
382 /**
383 * @tc.number : FetchFrameAtTime_API_0100
384 * @tc.name : FetchFrameAtTime size
385 * @tc.desc : FetchFrameAtTime API size
386 */
387 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0100, TestSize.Level2)
388 {
389 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
390 std::string("H264_AAC.mp4");
391 auto helper = AVMetadataHelperServer::Create();
392 ASSERT_NE(nullptr, helper);
393 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
394
395 OutputConfiguration param = {-1, 316, PixelFormat::RGB_565};
396 int64_t timeUs = 0;
397 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
398 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
399 EXPECT_NE(nullptr, frame);
400 param = {dstWidthMin - 1, 316, PixelFormat::RGB_565};
401 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
402 EXPECT_NE(nullptr, frame);
403 param = {dstWidthMin, 316, PixelFormat::RGB_565};
404 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
405 EXPECT_NE(nullptr, frame);
406 param = {dstWidthMax, 316, PixelFormat::RGB_565};
407 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
408 EXPECT_NE(nullptr, frame);
409 param = {dstWidthMax + 1, 316, PixelFormat::RGB_565};
410 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
411 EXPECT_NE(nullptr, frame);
412 param = {316, -1, PixelFormat::RGB_565};
413 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
414 EXPECT_NE(nullptr, frame);
415 param = {316, 0, PixelFormat::RGB_565};
416 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
417 EXPECT_NE(nullptr, frame);
418 param = {316, dstHeightMin - 1, PixelFormat::RGB_565};
419 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
420 EXPECT_NE(nullptr, frame);
421 param = {316, dstHeightMin, PixelFormat::RGB_565};
422 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
423 EXPECT_NE(nullptr, frame);
424 param = {316, dstHeightMax, PixelFormat::RGB_565};
425 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
426 EXPECT_NE(nullptr, frame);
427 param = {316, dstHeightMax + 1, PixelFormat::RGB_565};
428 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
429 EXPECT_NE(nullptr, frame);
430 timeUs = -1;
431 param = {316, 316, PixelFormat::RGB_565};
432 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
433 EXPECT_NE(nullptr, frame);
434 helper->Release();
435 }
436
437 /**
438 * @tc.number : FetchFrameAtTime_API_0200
439 * @tc.name : FetchFrameAtTime AVMetadataQueryOption
440 * @tc.desc : FetchFrameAtTime API AVMetadataQueryOption
441 */
442 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0200, TestSize.Level2)
443 {
444 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
445 std::string("H264_AAC.mp4");
446 auto helper = AVMetadataHelperServer::Create();
447 ASSERT_NE(nullptr, helper);
448 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
449
450 OutputConfiguration param = {-1, 316, PixelFormat::RGB_565};
451 int64_t timeUs = 0;
452 int32_t queryOption = AVMetadataQueryOption(100);
453 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
454 EXPECT_NE(nullptr, frame);
455 helper->Release();
456 }
457
458 /**
459 * @tc.number : FetchFrameAtTime_API_0300
460 * @tc.name : FetchFrameAtTime PixelFormat
461 * @tc.desc : FetchFrameAtTime API PixelFormat
462 */
463 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0300, TestSize.Level2)
464 {
465 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
466 std::string("H264_AAC.mp4");
467 auto helper = AVMetadataHelperServer::Create();
468 ASSERT_NE(nullptr, helper);
469 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
470
471 OutputConfiguration param = {-1, 316, PixelFormat::UNKNOWN};
472 int64_t timeUs = 0;
473 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
474 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
475 EXPECT_NE(nullptr, frame);
476 helper->Release();
477 }
478
479 /**
480 * @tc.number : FetchFrameAtTime_API_0400
481 * @tc.name : FetchFrameAtTime PixelFormat
482 * @tc.desc : FetchFrameAtTime API PixelFormat RGBA_8888
483 */
484 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0400, TestSize.Level2)
485 {
486 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
487 std::string("H264_AAC.mp4");
488 auto helper = AVMetadataHelperServer::Create();
489 ASSERT_NE(nullptr, helper);
490 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
491
492 OutputConfiguration param = {-1, 316, PixelFormat::RGBA_8888};
493 int64_t timeUs = 0;
494 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
495 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
496 EXPECT_NE(nullptr, frame);
497 helper->Release();
498 }
499
500 /**
501 * @tc.number : FetchFrameAtTime
502 * @tc.name : FetchFrameAtTime AV_META_USAGE_META_ONLY
503 * @tc.desc : FetchFrameAtTime API
504 */
HWTEST_F(AVMetadataUnitTest,FetchFrameAtTime_API_0500,Level2)505 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0500, Level2)
506 {
507 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
508 std::string("H264_AAC.mp4");
509 auto helper = AVMetadataHelperServer::Create();
510 ASSERT_NE(nullptr, helper);
511 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_META_ONLY));
512
513 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
514 EXPECT_NE(value, " ");
515 helper->ResolveMetadata();
516 OutputConfiguration param = {-1, 316, PixelFormat::RGB_565};
517 int64_t timeUs = 0;
518 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
519 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
520 EXPECT_NE(nullptr, frame);
521 helper->Release();
522 }
523
524 /**
525 * @tc.number : SetSource_API_0100
526 * @tc.name : SetSource AVMetadataUsage
527 * @tc.desc : SetSource API AVMetadataUsage
528 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0100,Level2)529 HWTEST_F(AVMetadataUnitTest, SetSource_API_0100, Level2)
530 {
531 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
532 std::string("H264_AAC.mp4");
533 auto helper = AVMetadataHelperServer::Create();
534 ASSERT_NE(nullptr, helper);
535 EXPECT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage(100)));
536 helper->Release();
537 }
538
539 /**
540 * @tc.number : SetSource_API_0200
541 * @tc.name : SetSource
542 * @tc.desc : SetSource API
543 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0200,Level2)544 HWTEST_F(AVMetadataUnitTest, SetSource_API_0200, Level2)
545 {
546 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
547 std::string("H264_AAC.mp4");
548 auto helper = AVMetadataHelperServer::Create();
549 ASSERT_NE(nullptr, helper);
550 OutputConfiguration param = {-1, 316, PixelFormat::RGB_565};
551 int64_t timeUs = 0;
552 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
553 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
554 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
555 EXPECT_NE(value, " ");
556 helper->ResolveMetadata();
557 helper->Release();
558 }
559
560 /**
561 * @tc.number : SetSource_API_0400
562 * @tc.name : SetSource 1kb.mp3
563 * @tc.desc : SetSource API
564 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0400,Level2)565 HWTEST_F(AVMetadataUnitTest, SetSource_API_0400, Level2)
566 {
567 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
568 std::string("aac_44100Hz_143kbs_stereo.aac");
569 auto helper = AVMetadataHelperServer::Create();
570 ASSERT_NE(nullptr, helper);
571 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
572
573 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
574 EXPECT_EQ(value, "");
575 helper->ResolveMetadata(AV_KEY_HAS_AUDIO);
576 EXPECT_EQ(value, "");
577 helper->ResolveMetadata();
578 OutputConfiguration param = {-1, 316, PixelFormat::RGB_565};
579 int64_t timeUs = 0;
580 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
581 auto frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
582 EXPECT_EQ(nullptr, frame);
583 helper->Release();
584 }
585
586 /**
587 * @tc.number : SetSource_API_0500
588 * @tc.name : SetSource error.mp4
589 * @tc.desc : SetSource API
590 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0500,Level2)591 HWTEST_F(AVMetadataUnitTest, SetSource_API_0500, Level2)
592 {
593 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
594 std::string("error.mp4");
595 auto helper = AVMetadataHelperServer::Create();
596 ASSERT_NE(nullptr, helper);
597 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
598 uint64_t time = 0;
599 OutputConfiguration param;
600 auto pixelMap = helper->FetchFrameYuv(0, time, param);
601 ASSERT_EQ(pixelMap, nullptr);
602 }
603
604 /**
605 * @tc.number : SetSource_API_0600
606 * @tc.name : SetSource invalid.mp4
607 * @tc.desc : SetSource API
608 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0600,Level2)609 HWTEST_F(AVMetadataUnitTest, SetSource_API_0600, Level2)
610 {
611 std::string uri = "file:///data/test/invalid.mp4";
612 auto helper = AVMetadataHelperServer::Create();
613 ASSERT_NE(nullptr, helper);
614 ASSERT_NE(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
615 }
616
617 /**
618 * @tc.number : GetTimeByFrameIndex_API_0100
619 * @tc.name : SetSource invalid.mp4
620 * @tc.desc : SetSource API
621 */
HWTEST_F(AVMetadataUnitTest,GetTimeByFrameIndex_API_0100,Level2)622 HWTEST_F(AVMetadataUnitTest, GetTimeByFrameIndex_API_0100, Level2)
623 {
624 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
625 std::string("H264_AAC.mp4");
626 auto helper = AVMetadataHelperServer::Create();
627 ASSERT_NE(nullptr, helper);
628 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
629 uint64_t time = 0;
630 ASSERT_EQ(MSERR_OK, helper->GetTimeByFrameIndex(0, time));
631 }
632
633 /**
634 * @tc.number : FetchFrameYuv_API_0100
635 * @tc.name : FetchFrameYuv SDR.mp4
636 * @tc.desc : FetchFrameYuv API
637 */
HWTEST_F(AVMetadataUnitTest,FetchFrameYuv_API_0100,Level2)638 HWTEST_F(AVMetadataUnitTest, FetchFrameYuv_API_0100, Level2)
639 {
640 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
641 std::string("SDR.mp4");
642 auto helper = AVMetadataHelperServer::Create();
643 ASSERT_NE(nullptr, helper);
644 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
645 int64_t time = 0;
646 OutputConfiguration param;
647 auto pixelMap = helper->FetchFrameYuv(time, 0, param);
648 ASSERT_NE(pixelMap, nullptr);
649 }
650
651 /**
652 * @tc.number : FetchFrameYuv_API_0200
653 * @tc.name : FetchFrameYuv HDR.mp4
654 * @tc.desc : FetchFrameYuv API
655 */
HWTEST_F(AVMetadataUnitTest,FetchFrameYuv_API_0200,Level2)656 HWTEST_F(AVMetadataUnitTest, FetchFrameYuv_API_0200, Level2)
657 {
658 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
659 std::string("HDR.mp4");
660 auto helper = AVMetadataHelperServer::Create();
661 ASSERT_NE(nullptr, helper);
662 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
663 int64_t time = 0;
664 OutputConfiguration param;
665 auto pixelMap = helper->FetchFrameYuv(time, 0, param);
666 ASSERT_NE(pixelMap, nullptr);
667 }
668 } // namespace Media
669 } // namespace OHOS
670