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 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 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
335 ASSERT_NE(nullptr, helper);
336 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
337 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
338 std::shared_ptr<AVSharedMemory> frame = helper->FetchArtPicture();
339 helper->SurfaceToFile(frame, testInfo_->name());
340 ASSERT_EQ(51.3046875*1024, frame->GetSize());
341 }
342
343 /**
344 * @tc.number : FetchArtPicture_Format_MP3_0200
345 * @tc.name : Get ArtPicture FROM H264_AAC.mp4
346 * @tc.desc : Get ArtPicture FROM H264_AAC.mp4
347 */
348 HWTEST_F(AVMetadataUnitTest, FetchArtPicture_Format_MP3_0200, Function | MediumTest | Level0)
349 {
350 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
351 std::string("H264_AAC.mp4");
352
353 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
354 ASSERT_NE(nullptr, helper);
355 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
356 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
357 std::shared_ptr<AVSharedMemory> frame = helper->FetchArtPicture();
358 ASSERT_EQ(nullptr, frame);
359 }
360
361 /**
362 * @tc.number : FetchFrameAtTime_Resolution_0100
363 * @tc.name : Resolution 170x170
364 * @tc.desc : Get THUMBNAIL
365 */
366 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0100, TestSize.Level0)
367 {
368 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
369 std::string("out_170_170.mp4");
370 GetThumbnail(uri);
371 }
372
373 /**
374 * @tc.number : FetchFrameAtTime_Resolution_0200
375 * @tc.name : Resolution 480x320
376 * @tc.desc : Get THUMBNAIL
377 */
378 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_Resolution_0200, TestSize.Level0)
379 {
380 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
381 std::string("out_480_320.mp4");
382 GetThumbnail(uri);
383 }
384
385 /**
386 * @tc.number : FetchFrameAtTime_API_0100
387 * @tc.name : FetchFrameAtTime size
388 * @tc.desc : FetchFrameAtTime API size
389 */
390 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0100, TestSize.Level2)
391 {
392 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
393 std::string("H264_AAC.mp4");
394 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
395 ASSERT_NE(nullptr, helper);
396 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
397 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
398
399 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
400 int64_t timeUs = 0;
401 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
402 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
403 EXPECT_NE(nullptr, frame);
404 param = {dstWidthMin - 1, 316, PixelFormat::RGB_565};
405 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
406 EXPECT_NE(nullptr, frame);
407 param = {dstWidthMin, 316, PixelFormat::RGB_565};
408 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
409 EXPECT_NE(nullptr, frame);
410 param = {dstWidthMax, 316, PixelFormat::RGB_565};
411 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
412 EXPECT_NE(nullptr, frame);
413 param = {dstWidthMax + 1, 316, PixelFormat::RGB_565};
414 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
415 EXPECT_NE(nullptr, frame);
416 param = {316, -1, PixelFormat::RGB_565};
417 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
418 EXPECT_NE(nullptr, frame);
419 param = {316, 0, PixelFormat::RGB_565};
420 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
421 EXPECT_NE(nullptr, frame);
422 param = {316, dstHeightMin - 1, PixelFormat::RGB_565};
423 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
424 EXPECT_NE(nullptr, frame);
425 param = {316, dstHeightMin, PixelFormat::RGB_565};
426 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
427 EXPECT_NE(nullptr, frame);
428 param = {316, dstHeightMax, PixelFormat::RGB_565};
429 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
430 EXPECT_NE(nullptr, frame);
431 param = {316, dstHeightMax + 1, PixelFormat::RGB_565};
432 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
433 EXPECT_NE(nullptr, frame);
434 timeUs = -1;
435 param = {316, 316, PixelFormat::RGB_565};
436 frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
437 EXPECT_NE(nullptr, frame);
438 helper->Release();
439 }
440
441 /**
442 * @tc.number : FetchFrameAtTime_API_0200
443 * @tc.name : FetchFrameAtTime AVMetadataQueryOption
444 * @tc.desc : FetchFrameAtTime API AVMetadataQueryOption
445 */
446 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0200, TestSize.Level2)
447 {
448 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
449 std::string("H264_AAC.mp4");
450 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
451 ASSERT_NE(nullptr, helper);
452 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
453 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
454
455 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
456 int64_t timeUs = 0;
457 int32_t queryOption = AVMetadataQueryOption(100);
458 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
459 EXPECT_NE(nullptr, frame);
460 helper->Release();
461 }
462
463 /**
464 * @tc.number : FetchFrameAtTime_API_0300
465 * @tc.name : FetchFrameAtTime PixelFormat
466 * @tc.desc : FetchFrameAtTime API PixelFormat
467 */
468 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0300, TestSize.Level2)
469 {
470 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
471 std::string("H264_AAC.mp4");
472 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
473 ASSERT_NE(nullptr, helper);
474 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
475 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
476
477 struct PixelMapParams param = {-1, 316, PixelFormat::UNKNOWN};
478 int64_t timeUs = 0;
479 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
480 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
481 EXPECT_NE(nullptr, frame);
482 helper->Release();
483 }
484
485 /**
486 * @tc.number : FetchFrameAtTime_API_0400
487 * @tc.name : FetchFrameAtTime PixelFormat
488 * @tc.desc : FetchFrameAtTime API PixelFormat RGBA_8888
489 */
490 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0400, TestSize.Level2)
491 {
492 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
493 std::string("H264_AAC.mp4");
494 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
495 ASSERT_NE(nullptr, helper);
496 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
497 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
498
499 struct PixelMapParams param = {-1, 316, PixelFormat::RGBA_8888};
500 int64_t timeUs = 0;
501 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
502 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
503 EXPECT_NE(nullptr, frame);
504 helper->Release();
505 }
506
507 /**
508 * @tc.number : FetchFrameAtTime
509 * @tc.name : FetchFrameAtTime AV_META_USAGE_META_ONLY
510 * @tc.desc : FetchFrameAtTime API
511 */
HWTEST_F(AVMetadataUnitTest,FetchFrameAtTime_API_0500,Level2)512 HWTEST_F(AVMetadataUnitTest, FetchFrameAtTime_API_0500, Level2)
513 {
514 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
515 std::string("H264_AAC.mp4");
516 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
517 ASSERT_NE(nullptr, helper);
518 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
519 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_META_ONLY));
520
521 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
522 EXPECT_NE(value, " ");
523 helper->ResolveMetadata();
524 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
525 int64_t timeUs = 0;
526 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
527 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
528 EXPECT_NE(nullptr, frame);
529 helper->Release();
530 }
531
532 /**
533 * @tc.number : SetSource_API_0100
534 * @tc.name : SetSource AVMetadataUsage
535 * @tc.desc : SetSource API AVMetadataUsage
536 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0100,Level2)537 HWTEST_F(AVMetadataUnitTest, SetSource_API_0100, Level2)
538 {
539 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
540 std::string("H264_AAC.mp4");
541 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
542 ASSERT_NE(nullptr, helper);
543 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
544 EXPECT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage(100)));
545 helper->Release();
546 }
547
548 /**
549 * @tc.number : SetSource_API_0200
550 * @tc.name : SetSource
551 * @tc.desc : SetSource API
552 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0200,Level2)553 HWTEST_F(AVMetadataUnitTest, SetSource_API_0200, Level2)
554 {
555 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
556 std::string("H264_AAC.mp4");
557 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
558 ASSERT_NE(nullptr, helper);
559 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
560 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
561 int64_t timeUs = 0;
562 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
563 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
564 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
565 EXPECT_NE(value, " ");
566 helper->ResolveMetadata();
567 helper->Release();
568 }
569
570 /**
571 * @tc.number : SetSource_API_0400
572 * @tc.name : SetSource 1kb.mp3
573 * @tc.desc : SetSource API
574 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0400,Level2)575 HWTEST_F(AVMetadataUnitTest, SetSource_API_0400, Level2)
576 {
577 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
578 std::string("aac_44100Hz_143kbs_stereo.aac");
579 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
580 ASSERT_NE(nullptr, helper);
581 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
582 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
583
584 std::string value = helper->ResolveMetadata(AV_KEY_HAS_VIDEO);
585 EXPECT_EQ(value, "");
586 helper->ResolveMetadata(AV_KEY_HAS_AUDIO);
587 EXPECT_EQ(value, "");
588 helper->ResolveMetadata();
589 struct PixelMapParams param = {-1, 316, PixelFormat::RGB_565};
590 int64_t timeUs = 0;
591 int32_t queryOption = AVMetadataQueryOption::AV_META_QUERY_NEXT_SYNC;
592 std::shared_ptr<PixelMap> frame = helper->FetchFrameAtTime(timeUs, queryOption, param);
593 EXPECT_EQ(nullptr, frame);
594 helper->Release();
595 }
596
597 /**
598 * @tc.number : SetSource_API_0500
599 * @tc.name : SetSource error.mp4
600 * @tc.desc : SetSource API
601 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0500,Level2)602 HWTEST_F(AVMetadataUnitTest, SetSource_API_0500, Level2)
603 {
604 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
605 std::string("error.mp4");
606 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
607 ASSERT_NE(nullptr, helper);
608 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
609 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
610 uint64_t time = 0;
611 PixelMapParams param;
612 auto pixelMap = helper->FetchFrameYuv(0, time, param);
613 ASSERT_EQ(pixelMap, nullptr);
614 }
615
616 /**
617 * @tc.number : SetSource_API_0600
618 * @tc.name : SetSource invalid.mp4
619 * @tc.desc : SetSource API
620 */
HWTEST_F(AVMetadataUnitTest,SetSource_API_0600,Level2)621 HWTEST_F(AVMetadataUnitTest, SetSource_API_0600, Level2)
622 {
623 std::string uri = "file:///data/test/invalid.mp4";
624 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
625 ASSERT_NE(nullptr, helper);
626 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
627 ASSERT_NE(MSERR_OK, helper->SetSource(uri, 0, 0, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
628 }
629
630 /**
631 * @tc.number : GetTimeByFrameIndex_API_0100
632 * @tc.name : SetSource invalid.mp4
633 * @tc.desc : SetSource API
634 */
HWTEST_F(AVMetadataUnitTest,GetTimeByFrameIndex_API_0100,Level2)635 HWTEST_F(AVMetadataUnitTest, GetTimeByFrameIndex_API_0100, Level2)
636 {
637 std::string uri = AVMetadataTestBase::GetInstance().GetMountPath() +
638 std::string("H264_AAC.mp4");
639 std::shared_ptr<AVMetadataMock> helper = std::make_shared<AVMetadataMock>();
640 ASSERT_NE(nullptr, helper);
641 ASSERT_EQ(true, helper->CreateAVMetadataHelper());
642 ASSERT_EQ(MSERR_OK, helper->SetSource(uri, AVMetadataUsage::AV_META_USAGE_PIXEL_MAP));
643 uint64_t time = 0;
644 ASSERT_EQ(MSERR_OK, helper->GetTimeByFrameIndex(0, time));
645 }
646 } // namespace Media
647 } // namespace OHOS