1 /*
2 * Copyright (C) 2022 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 Function: compare metadata
30 Description: test for metadata
31 Input: uri, expected MetaData
32 Return: null
33 */
CheckMeta(std::string uri,std::unordered_map<int32_t,std::string> expectMeta)34 void AVMetadataUnitTest::CheckMeta(std::string uri, std::unordered_map<int32_t, std::string> expectMeta)
35 {
36 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
37 ASSERT_NE(nullptr, helper);
38 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
39 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_META_ONLY));
40 for (auto &item : expectMeta) {
41 std::string value = helper->ResolveMetadata(item.first);
42 EXPECT_EQ(AVMetadataTestBase::GetInstance().CompareMetadata(item.first, value, item.second), true);
43 }
44 auto resultMetas = helper->ResolveMetadata();
45 EXPECT_EQ(AVMetadataTestBase::GetInstance().CompareMetadata(resultMetas, expectMeta), true);
46 helper->Release();
47 }
48
49 /**
50 * @tc.number : GetThumbnail
51 * @tc.name : Get Thumbnail
52 * @tc.desc : Get THUMBNAIL Function case
53 */
GetThumbnail(const std::string uri)54 void AVMetadataUnitTest::GetThumbnail(const std::string uri)
55 {
56 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
57 ASSERT_NE(nullptr, helper);
58 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
59 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
60
61 struct PixelMapParams param = {-1, -1, PixelFormat::RGB_565};
62 int64_t timeUs = 0;
63 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
64 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
65 ASSERT_NE(nullptr, frame);
66 helper->FrameToFile(frame, testInfo_->name(), timeUs, queryOption);
67 helper->FrameToJpeg(frame, testInfo_->name(), timeUs, queryOption);
68 timeUs = 5000000; // 5000000us
69 queryOption = AVMetadataQueryOption::AV_META_QUERY_PREVIOUS_SYNC;
70 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
71 ASSERT_NE(nullptr, frame);
72 helper->FrameToFile(frame, testInfo_->name(), timeUs, queryOption);
73 helper->FrameToJpeg(frame, testInfo_->name(), timeUs, queryOption);
74
75 param = {-1, -1, PixelFormat::RGB_888};
76 queryOption = AVMetadataQueryOption::AV_META_QUERY_CLOSEST_SYNC;
77 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
78 ASSERT_NE(nullptr, frame);
79 helper->FrameToFile(frame, testInfo_->name(), timeUs, queryOption);
80 helper->FrameToJpeg(frame, testInfo_->name(), timeUs, queryOption);
81
82 timeUs = 0;
83 queryOption = AVMetadataQueryOption::AV_META_QUERY_CLOSEST;
84 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
85 ASSERT_NE(nullptr, frame);
86 helper->FrameToFile(frame, testInfo_->name(), timeUs, queryOption);
87 helper->FrameToJpeg(frame, testInfo_->name(), timeUs, queryOption);
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 std::unordered_map<int32_t, std::string> expectMeta = {
99 {AV_KEY_ALBUM, "media"},
100 {AV_KEY_ALBUM_ARTIST, "media_test"},
101 {AV_KEY_ARTIST, "元数据测试"},
102 {AV_KEY_AUTHOR, ""},
103 {AV_KEY_COMPOSER, "测试"},
104 {AV_KEY_DURATION, "10030"},
105 {AV_KEY_GENRE, "Lyrical"},
106 {AV_KEY_HAS_AUDIO, "yes"},
107 {AV_KEY_HAS_VIDEO, "yes"},
108 {AV_KEY_MIME_TYPE, "video/mp4"},
109 {AV_KEY_NUM_TRACKS, "2"},
110 {AV_KEY_SAMPLE_RATE, "44100"},
111 {AV_KEY_TITLE, "test"},
112 {AV_KEY_VIDEO_HEIGHT, "480"},
113 {AV_KEY_VIDEO_WIDTH, "720"},
114 {AV_KEY_DATE_TIME, "2022-05-29 22:10:43"},
115 };
116 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
117 std::string("H264_AAC.mp4");
118 CheckMeta(uri, expectMeta);
119 }
120
121 /**
122 * @tc.number : ResolveMetadata_Format_MP4_0200
123 * @tc.name : 02.MP4 format Get MetaData(H264+MP3)
124 * @tc.desc : test ResolveMetadata
125 */
126 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0200, Function | MediumTest | Level0)
127 {
128 std::unordered_map<int32_t, std::string> expectMeta = {
129 {AV_KEY_ALBUM, "media"},
130 {AV_KEY_ALBUM_ARTIST, "media_test"},
131 {AV_KEY_ARTIST, "元数据测试"},
132 {AV_KEY_AUTHOR, ""},
133 {AV_KEY_COMPOSER, "测试"},
134 {AV_KEY_DURATION, "10030"},
135 {AV_KEY_GENRE, "Lyrical"},
136 {AV_KEY_HAS_AUDIO, "yes"},
137 {AV_KEY_HAS_VIDEO, "yes"},
138 {AV_KEY_MIME_TYPE, "video/mp4"},
139 {AV_KEY_NUM_TRACKS, "2"},
140 {AV_KEY_SAMPLE_RATE, "44100"},
141 {AV_KEY_TITLE, "test"},
142 {AV_KEY_VIDEO_HEIGHT, "480"},
143 {AV_KEY_VIDEO_WIDTH, "720"},
144 {AV_KEY_DATE_TIME, "2022"},
145 };
146 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
147 std::string("/H264_MP3.mp4");
148 CheckMeta(uri, expectMeta);
149 }
150
151 /**
152 * @tc.number : ResolveMetadata_Format_MP4_0300
153 * @tc.name : 03.MP4 format Get MetaData(MPEG2+AAC)
154 * @tc.desc : test ResolveMetadata
155 */
156 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0300, Function | MediumTest | Level0)
157 {
158 std::unordered_map<int32_t, std::string> expectMeta = {
159 {AV_KEY_ALBUM, "media"},
160 {AV_KEY_ALBUM_ARTIST, "media_test"},
161 {AV_KEY_ARTIST, "元数据测试"},
162 {AV_KEY_AUTHOR, ""},
163 {AV_KEY_COMPOSER, "测试"},
164 {AV_KEY_DURATION, "10030"},
165 {AV_KEY_GENRE, "Lyrical"},
166 {AV_KEY_HAS_AUDIO, "yes"},
167 {AV_KEY_HAS_VIDEO, "yes"},
168 {AV_KEY_MIME_TYPE, "video/mp4"},
169 {AV_KEY_NUM_TRACKS, "2"},
170 {AV_KEY_SAMPLE_RATE, "44100"},
171 {AV_KEY_TITLE, "test"},
172 {AV_KEY_VIDEO_HEIGHT, "480"},
173 {AV_KEY_VIDEO_WIDTH, "720"},
174 {AV_KEY_DATE_TIME, "2012-06-30 22:46:43"},
175 };
176 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
177 std::string("/MPEG2_AAC.mp4");
178 CheckMeta(uri, expectMeta);
179 }
180
181 /**
182 * @tc.number : ResolveMetadata_Format_MP4_0400
183 * @tc.name : 04.MP4 format Get MetaData(MPEG2+MP3)
184 * @tc.desc : test ResolveMetadata
185 */
186 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0400, Function | MediumTest | Level0)
187 {
188 std::unordered_map<int32_t, std::string> expectMeta = {
189 {AV_KEY_ALBUM, "media"},
190 {AV_KEY_ALBUM_ARTIST, "media_test"},
191 {AV_KEY_ARTIST, "元数据测试"},
192 {AV_KEY_AUTHOR, ""},
193 {AV_KEY_COMPOSER, "测试"},
194 {AV_KEY_DURATION, "10030"},
195 {AV_KEY_GENRE, "Lyrical"},
196 {AV_KEY_HAS_AUDIO, "yes"},
197 {AV_KEY_HAS_VIDEO, "yes"},
198 {AV_KEY_MIME_TYPE, "video/mp4"},
199 {AV_KEY_NUM_TRACKS, "2"},
200 {AV_KEY_SAMPLE_RATE, "44100"},
201 {AV_KEY_TITLE, "test"},
202 {AV_KEY_VIDEO_HEIGHT, "480"},
203 {AV_KEY_VIDEO_WIDTH, "720"},
204 {AV_KEY_DATE_TIME, "2022-05-19"},
205 };
206 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
207 std::string("/MPEG2_MP3.mp4");
208 CheckMeta(uri, expectMeta);
209 }
210
211 /**
212 * @tc.number : ResolveMetadata_Format_MP4_0500
213 * @tc.name : 05.MP4 format Get MetaData(MPEG4+AAC)
214 * @tc.desc : test ResolveMetadata
215 */
216 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0500, Function | MediumTest | Level0)
217 {
218 std::unordered_map<int32_t, std::string> expectMeta = {
219 {AV_KEY_ALBUM, "media"},
220 {AV_KEY_ALBUM_ARTIST, "media_test"},
221 {AV_KEY_ARTIST, "元数据测试"},
222 {AV_KEY_AUTHOR, ""},
223 {AV_KEY_COMPOSER, "测试"},
224 {AV_KEY_DURATION, "10030"},
225 {AV_KEY_GENRE, "Lyrical"},
226 {AV_KEY_HAS_AUDIO, "yes"},
227 {AV_KEY_HAS_VIDEO, "yes"},
228 {AV_KEY_MIME_TYPE, "video/mp4"},
229 {AV_KEY_NUM_TRACKS, "2"},
230 {AV_KEY_SAMPLE_RATE, "44100"},
231 {AV_KEY_TITLE, "test"},
232 {AV_KEY_VIDEO_HEIGHT, "480"},
233 {AV_KEY_VIDEO_WIDTH, "720"},
234 {AV_KEY_DATE_TIME, "2022-05-29 22:46:43"},
235 };
236 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
237 std::string("/MPEG4_AAC.mp4");
238 CheckMeta(uri, expectMeta);
239 }
240
241 /**
242 * @tc.number : ResolveMetadata_Format_MP4_0600
243 * @tc.name : 06.MP4 format Get MetaData(MPEG4+MP3)
244 * @tc.desc : test ResolveMetadata
245 */
246 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP4_0600, Function | MediumTest | Level0)
247 {
248 std::unordered_map<int32_t, std::string> expectMeta = {
249 {AV_KEY_ALBUM, "media"},
250 {AV_KEY_ALBUM_ARTIST, "media_test"},
251 {AV_KEY_ARTIST, "元数据测试"},
252 {AV_KEY_AUTHOR, ""},
253 {AV_KEY_COMPOSER, "测试"},
254 {AV_KEY_DURATION, "10030"},
255 {AV_KEY_GENRE, "Lyrical"},
256 {AV_KEY_HAS_AUDIO, "yes"},
257 {AV_KEY_HAS_VIDEO, "yes"},
258 {AV_KEY_MIME_TYPE, "video/mp4"},
259 {AV_KEY_NUM_TRACKS, "2"},
260 {AV_KEY_SAMPLE_RATE, "44100"},
261 {AV_KEY_TITLE, "test"},
262 {AV_KEY_VIDEO_HEIGHT, "480"},
263 {AV_KEY_VIDEO_WIDTH, "720"},
264 {AV_KEY_DATE_TIME, "2022-05"},
265 };
266 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
267 std::string("/MPEG4_MP3.mp4");
268 CheckMeta(uri, expectMeta);
269 }
270
271 /**
272 * @tc.number : ResolveMetadata_Format_M4A_0100
273 * @tc.name : 01.M4A format Get MetaData
274 * @tc.desc : test ResolveMetadata
275 */
276 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_M4A_0100, Function | MediumTest | Level0)
277 {
278 std::unordered_map<int32_t, std::string> expectMeta = {
279 {AV_KEY_ALBUM, "media"},
280 {AV_KEY_ALBUM_ARTIST, "media_test"},
281 {AV_KEY_ARTIST, "元数据测试"},
282 {AV_KEY_AUTHOR, ""},
283 {AV_KEY_COMPOSER, "测试"},
284 {AV_KEY_DURATION, "219562"},
285 {AV_KEY_GENRE, "Lyrical"},
286 {AV_KEY_HAS_AUDIO, "yes"},
287 {AV_KEY_HAS_VIDEO, ""},
288 {AV_KEY_MIME_TYPE, "audio/mp4"},
289 {AV_KEY_NUM_TRACKS, "1"},
290 {AV_KEY_SAMPLE_RATE, "48000"},
291 {AV_KEY_TITLE, "test"},
292 {AV_KEY_VIDEO_HEIGHT, ""},
293 {AV_KEY_VIDEO_WIDTH, ""},
294 {AV_KEY_DATE_TIME, "2015-11-23"},
295 };
296 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
297 std::string("/aac_48000Hz_70kbs_mono.m4a");
298 CheckMeta(uri, expectMeta);
299 }
300
301 /**
302 * @tc.number : ResolveMetadata_Format_MP3_0100
303 * @tc.name : 01.MP3 format Get MetaData
304 * @tc.desc : test ResolveMetadata
305 */
306 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_MP3_0100, Function | MediumTest | Level0)
307 {
308 std::unordered_map<int32_t, std::string> expectMeta = {
309 {AV_KEY_ALBUM, "media"},
310 {AV_KEY_ALBUM_ARTIST, "media_test"},
311 {AV_KEY_ARTIST, "元数据测试"},
312 {AV_KEY_AUTHOR, "media"},
313 {AV_KEY_COMPOSER, "测试"},
314 {AV_KEY_DURATION, "219600"},
315 {AV_KEY_GENRE, "Lyrical"},
316 {AV_KEY_HAS_AUDIO, "yes"},
317 {AV_KEY_HAS_VIDEO, ""},
318 {AV_KEY_MIME_TYPE, "audio/mpeg"},
319 {AV_KEY_NUM_TRACKS, "1"},
320 {AV_KEY_SAMPLE_RATE, "48000"},
321 {AV_KEY_TITLE, "test"},
322 {AV_KEY_VIDEO_HEIGHT, ""},
323 {AV_KEY_VIDEO_WIDTH, ""},
324 {AV_KEY_DATE_TIME, "2022-05"},
325 };
326 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
327 std::string("/mp3_48000Hz_64kbs_mono.mp3");
328 CheckMeta(uri, expectMeta);
329 }
330
331 /**
332 * @tc.number : ResolveMetadata_Format_AAC_0100
333 * @tc.name : 01.AAC format Get MetaData
334 * @tc.desc : test ResolveMetadata
335 */
336 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_AAC_0100, Function | MediumTest | Level0)
337 {
338 std::unordered_map<int32_t, std::string> expectMeta = {
339 {AV_KEY_ALBUM, ""},
340 {AV_KEY_ALBUM_ARTIST, ""},
341 {AV_KEY_ARTIST, ""},
342 {AV_KEY_AUTHOR, ""},
343 {AV_KEY_COMPOSER, ""},
344 {AV_KEY_DURATION, "219780"},
345 {AV_KEY_GENRE, ""},
346 {AV_KEY_HAS_AUDIO, "yes"},
347 {AV_KEY_HAS_VIDEO, ""},
348 {AV_KEY_MIME_TYPE, "audio/aac-adts"},
349 {AV_KEY_NUM_TRACKS, "1"},
350 {AV_KEY_SAMPLE_RATE, "44100"},
351 {AV_KEY_TITLE, ""},
352 {AV_KEY_VIDEO_HEIGHT, ""},
353 {AV_KEY_VIDEO_WIDTH, ""},
354 };
355 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
356 std::string("/aac_44100Hz_143kbs_stereo.aac");
357 CheckMeta(uri, expectMeta);
358 }
359
360 /**
361 * @tc.number : ResolveMetadata_Format_OGG_0100
362 * @tc.name : 01.OGG format Get MetaData
363 * @tc.desc : test ResolveMetadata
364 */
365 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_OGG_0100, Function | MediumTest | Level0)
366 {
367 std::unordered_map<int32_t, std::string> expectMeta = {
368 {AV_KEY_ALBUM, "media"},
369 {AV_KEY_ALBUM_ARTIST, "media_test"},
370 {AV_KEY_ARTIST, "元数据测试"},
371 {AV_KEY_AUTHOR, "media"},
372 {AV_KEY_COMPOSER, "测试"},
373 {AV_KEY_DURATION, "219550"},
374 {AV_KEY_GENRE, "Lyrical"},
375 {AV_KEY_HAS_AUDIO, "yes"},
376 {AV_KEY_HAS_VIDEO, ""},
377 {AV_KEY_MIME_TYPE, "audio/ogg"},
378 {AV_KEY_NUM_TRACKS, "1"},
379 {AV_KEY_SAMPLE_RATE, "48000"},
380 {AV_KEY_TITLE, "test"},
381 {AV_KEY_VIDEO_HEIGHT, ""},
382 {AV_KEY_VIDEO_WIDTH, ""},
383 {AV_KEY_DATE_TIME, "2015-11-23"},
384 };
385 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
386 std::string("/vorbis_48000Hz_80kbs_mono.ogg");
387 CheckMeta(uri, expectMeta);
388 }
389
390 /**
391 * @tc.number : ResolveMetadata_Format_WAV_0100
392 * @tc.name : 01.WAV format Get MetaData
393 * @tc.desc : test ResolveMetadata
394 */
395 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_WAV_0100, Function | MediumTest | Level0)
396 {
397 std::unordered_map<int32_t, std::string> expectMeta = {
398 {AV_KEY_ALBUM, "media"},
399 {AV_KEY_ALBUM_ARTIST, ""},
400 {AV_KEY_ARTIST, "元数据测试"},
401 {AV_KEY_AUTHOR, ""},
402 {AV_KEY_COMPOSER, ""},
403 {AV_KEY_DURATION, "5460"},
404 {AV_KEY_GENRE, "Lyrical"},
405 {AV_KEY_HAS_AUDIO, "yes"},
406 {AV_KEY_HAS_VIDEO, ""},
407 {AV_KEY_MIME_TYPE, "audio/wav"},
408 {AV_KEY_NUM_TRACKS, "1"},
409 {AV_KEY_SAMPLE_RATE, "48000"},
410 {AV_KEY_TITLE, "test"},
411 {AV_KEY_VIDEO_HEIGHT, ""},
412 {AV_KEY_VIDEO_WIDTH, ""},
413 {AV_KEY_DATE_TIME, "2022-05-29 22:46:43"},
414 };
415 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
416 std::string("/pcm_s16le_48000Hz_768kbs_mono.wav");
417 CheckMeta(uri, expectMeta);
418 }
419
420 /**
421 * @tc.number : ResolveMetadata_Format_WAV_0200
422 * @tc.name : 01.WAV format Get MetaData
423 * @tc.desc : test ResolveMetadata
424 */
425 HWTEST_F(AVMetadataUnitTest, ResolveMetadata_Format_WAV_0200, Function | MediumTest | Level0)
426 {
427 std::unordered_map<int32_t, std::string> expectMeta = {
428 {AV_KEY_ALBUM, "media"},
429 {AV_KEY_ALBUM_ARTIST, ""},
430 {AV_KEY_ARTIST, "元数据测试"},
431 {AV_KEY_AUTHOR, ""},
432 {AV_KEY_COMPOSER, ""},
433 {AV_KEY_DURATION, "5460"},
434 {AV_KEY_GENRE, "Lyrical"},
435 {AV_KEY_HAS_AUDIO, "yes"},
436 {AV_KEY_HAS_VIDEO, ""},
437 {AV_KEY_MIME_TYPE, "audio/wav"},
438 {AV_KEY_NUM_TRACKS, "1"},
439 {AV_KEY_SAMPLE_RATE, "48000"},
440 {AV_KEY_TITLE, "test"},
441 {AV_KEY_VIDEO_HEIGHT, ""},
442 {AV_KEY_VIDEO_WIDTH, ""},
443 {AV_KEY_DATE_TIME, "2022"},
444 };
445 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
446 std::string("/pcm_s16le_48000Hz_768kbs_mono_date.wav");
447 CheckMeta(uri, expectMeta);
448 }
449
450 /**
451 * @tc.number : FetchArtPicture_Format_MP3_0100
452 * @tc.name : Get SURFACE FROM MP3_SURFACE.mp3
453 * @tc.desc : Get SURFACE FROM MP3_SURFACE.mp3
454 */
455 HWTEST_F(AVMetadataUnitTest, FetchArtPicture_Format_MP3_0100, Function | MediumTest | Level0)
456 {
457 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
458 std::string("MP3_SURFACE.mp3");
459
460 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
461 ASSERT_NE(nullptr, helper);
462 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
463 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
464 std::shared_ptr<AVSharedMemory> frame = helper->FetchArtPicture();
465 helper->SurfaceToFile(frame, testInfo_->name());
466 ASSERT_EQ(51.3046875*1024, frame->GetSize());
467 }
468
469 /**
470 * @tc.number : FetchFrameAtTime_Resolution_0100
471 * @tc.name : Resolution 170x170
472 * @tc.desc : Get THUMBNAIL
473 */
474 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0100, TestSize.Level0)
475 {
476 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
477 std::string("out_170_170.mp4");
478 GetThumbnail(uri);
479 }
480
481 /**
482 * @tc.number : FetchFrameAtTime_Resolution_0200
483 * @tc.name : Resolution 480x320
484 * @tc.desc : Get THUMBNAIL
485 */
486 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0200, TestSize.Level0)
487 {
488 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
489 std::string("out_480_320.mp4");
490 GetThumbnail(uri);
491 }
492
493 /**
494 * @tc.number : FetchFrameAtTime_Resolution_0300
495 * @tc.name : Resolution 480x320
496 * @tc.desc : Get THUMBNAIL
497 */
498 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0300, TestSize.Level2)
499 {
500 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
501 std::string("MPEG2_AAC.mp4");
502 GetThumbnail(uri);
503 }
504
505 /**
506 * @tc.number : FetchFrameAtTime_Resolution_0400
507 * @tc.name : Resolution 480x320
508 * @tc.desc : Get THUMBNAIL
509 */
510 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0400, TestSize.Level0)
511 {
512 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
513 std::string("MPEG4_AAC.mp4");
514 GetThumbnail(uri);
515 }
516
517 /**
518 * @tc.number : FetchFrameAtTime_API_0100
519 * @tc.name : FetchFrameAtTime size
520 * @tc.desc : FetchFrameAtTime API size
521 */
522 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0100, TestSize.Level2)
523 {
524 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
525 std::string("H264_AAC.mp4");
526 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
527 ASSERT_NE(nullptr, helper);
528 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
529 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
530
531 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
532 int64_t timeUs = 0;
533 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
534 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
535 EXPECT_NE(nullptr, frame);
536 param = {dstWidthMin - 1, 316, PixelFormat::RGB_565};
537 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
538 EXPECT_EQ(nullptr, frame);
539 param = {dstWidthMin, 316, PixelFormat::RGB_565};
540 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
541 EXPECT_NE(nullptr, frame);
542 param = {dstWidthMax, 316, PixelFormat::RGB_565};
543 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
544 EXPECT_NE(nullptr, frame);
545 param = {dstWidthMax + 1, 316, PixelFormat::RGB_565};
546 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
547 EXPECT_EQ(nullptr, frame);
548 param = {316, -1, PixelFormat::RGB_565};
549 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
550 EXPECT_NE(nullptr, frame);
551 param = {316, 0, PixelFormat::RGB_565};
552 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
553 EXPECT_EQ(nullptr, frame);
554 param = {316, dstHeightMin - 1, PixelFormat::RGB_565};
555 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
556 EXPECT_EQ(nullptr, frame);
557 param = {316, dstHeightMin, PixelFormat::RGB_565};
558 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
559 EXPECT_NE(nullptr, frame);
560 param = {316, dstHeightMax, PixelFormat::RGB_565};
561 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
562 EXPECT_NE(nullptr, frame);
563 param = {316, dstHeightMax + 1, PixelFormat::RGB_565};
564 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
565 EXPECT_EQ(nullptr, frame);
566 timeUs = -1;
567 param = {316, 316, PixelFormat::RGB_565};
568 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
569 EXPECT_NE(nullptr, frame);
570 helper->Release();
571 }
572
573 /**
574 * @tc.number : FetchFrameAtTime_API_0200
575 * @tc.name : FetchFrameAtTime AVMetadataQueryOption
576 * @tc.desc : FetchFrameAtTime API AVMetadataQueryOption
577 */
578 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0200, TestSize.Level2)
579 {
580 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
581 std::string("H264_AAC.mp4");
582 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
583 ASSERT_NE(nullptr, helper);
584 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
585 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
586
587 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
588 int64_t timeUs = 0;
589 int32_t queryOption = AVMetadataQueryOption(100);
590 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
591 EXPECT_EQ(nullptr, frame);
592 helper->Release();
593 }
594
595 /**
596 * @tc.number : FetchFrameAtTime_API_0300
597 * @tc.name : FetchFrameAtTime PixelFormat
598 * @tc.desc : FetchFrameAtTime API PixelFormat
599 */
600 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0300, TestSize.Level2)
601 {
602 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
603 std::string("H264_AAC.mp4");
604 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
605 ASSERT_NE(nullptr, helper);
606 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
607 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
608
609 struct PixelMapParams param = {-1, 316, PixelFormat::UNKNOWN};
610 int64_t timeUs = 0;
611 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
612 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
613 EXPECT_EQ(nullptr, frame);
614 helper->Release();
615 }
616
617 /**
618 * @tc.number : FetchFrameAtTime_API_0400
619 * @tc.name : FetchFrameAtTime PixelFormat
620 * @tc.desc : FetchFrameAtTime API PixelFormat RGBA_8888
621 */
622 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0400, TestSize.Level2)
623 {
624 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
625 std::string("H264_AAC.mp4");
626 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
627 ASSERT_NE(nullptr, helper);
628 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
629 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
630
631 struct PixelMapParams param = {-1, 316, PixelFormat::RGBA_8888};
632 int64_t timeUs = 0;
633 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
634 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
635 EXPECT_NE(nullptr, frame);
636 helper->Release();
637 }
638
639 /**
640 * @tc.number : FetchFrameAtTime
641 * @tc.name : FetchFrameAtTime AV_META_USAGE_META_ONLY
642 * @tc.desc : FetchFrameAtTime API
643 */
HWTEST_F(AVMetadataUnitTest,FetchFrameAtTime_API_0500,Level2)644 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0500, Level2)
645 {
646 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
647 std::string("H264_AAC.mp4");
648 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
649 ASSERT_NE(nullptr, helper);
650 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
651 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_META_ONLY));
652
653 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
654 EXPECT_NE(value, " ");
655 helper->ResolveMetadata();
656 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
657 int64_t timeUs = 0;
658 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
659 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
660 EXPECT_EQ(nullptr, frame);
661 helper->Release();
662 }
663
664 /**
665 * @tc.number : SetSource_API_0100
666 * @tc.name : SetSource AVMetadataUsage
667 * @tc.desc : SetSource API AVMetadataUsage
668 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0100,Level2)669 HWTEST_F(AVMetadataUnitTest, SetSource_API_0100, Level2)
670 {
671 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
672 std::string("H264_AAC.mp4");
673 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
674 ASSERT_NE(nullptr, helper);
675 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
676 EXPECT_NE(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage(100)));
677 helper->Release();
678 }
679
680 /**
681 * @tc.number : SetSource_API_0200
682 * @tc.name : SetSource
683 * @tc.desc : SetSource API
684 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0200,Level2)685 HWTEST_F(AVMetadataUnitTest, SetSource_API_0200, Level2)
686 {
687 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
688 std::string("H264_AAC.mp4");
689 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
690 ASSERT_NE(nullptr, helper);
691 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
692 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
693 int64_t timeUs = 0;
694 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
695 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
696 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
697 EXPECT_NE(value, " ");
698 helper->ResolveMetadata();
699 helper->Release();
700 }
701
702 /**
703 * @tc.number : SetSource_API_0300
704 * @tc.name : SetSource 1kb.mp3
705 * @tc.desc : SetSource API
706 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0300,Level2)707 HWTEST_F(AVMetadataUnitTest, SetSource_API_0300, Level2)
708 {
709 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
710 std::string("1kb.mp3");
711 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
712 ASSERT_NE(nullptr, helper);
713 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
714 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
715
716 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
717 EXPECT_EQ(value, "");
718 helper->ResolveMetadata(AV_KEY_HAS_AUDIO);
719 EXPECT_EQ(value, "");
720 helper->ResolveMetadata();
721 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
722 int64_t timeUs = 0;
723 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
724 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
725 EXPECT_EQ(nullptr, frame);
726 helper->Release();
727 }
728
729 /**
730 * @tc.number : SetSource_API_0400
731 * @tc.name : SetSource 1kb.mp3
732 * @tc.desc : SetSource API
733 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0400,Level2)734 HWTEST_F(AVMetadataUnitTest, SetSource_API_0400, Level2)
735 {
736 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
737 std::string("aac_44100Hz_143kbs_stereo.aac");
738 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
739 ASSERT_NE(nullptr, helper);
740 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
741 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
742
743 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
744 EXPECT_EQ(value, "");
745 helper->ResolveMetadata(AV_KEY_HAS_AUDIO);
746 EXPECT_EQ(value, "");
747 helper->ResolveMetadata();
748 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
749 int64_t timeUs = 0;
750 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
751 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
752 EXPECT_EQ(nullptr, frame);
753 helper->Release();
754 }
755
756 /**
757 * @tc.number : SetSource_API_0500
758 * @tc.name : SetSource error.mp4
759 * @tc.desc : SetSource API
760 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0500,Level2)761 HWTEST_F(AVMetadataUnitTest, SetSource_API_0500, Level2)
762 {
763 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
764 std::string("error.mp4");
765 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
766 ASSERT_NE(nullptr, helper);
767 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
768 ASSERT_NE(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
769 }
770 } // namespace Media
771 } // namespace OHOS