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 <string>
17
18 #include "avmetadata_collector_unit_test.h"
19 #include "avmetadatahelper.h"
20 #include "buffer/avsharedmemorybase.h"
21 #include "media_log.h"
22 #include "meta/video_types.h"
23 #include "meta/any.h"
24 #include "time_format_utils.h"
25
26
27 using namespace OHOS;
28 using namespace OHOS::Media;
29 using namespace std;
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Media {
35 namespace Test {
SetUpTestCase(void)36 void AVMetaDataCollectorUnitTest::SetUpTestCase(void) {}
37
TearDownTestCase(void)38 void AVMetaDataCollectorUnitTest::TearDownTestCase(void) {}
39
SetUp(void)40 void AVMetaDataCollectorUnitTest::SetUp(void)
41 {
42 avmetaDataCollector = std::make_shared<AVMetaDataCollector>(mediaDemuxer_);
43 mediaDemuxer = std::make_shared<MockMediaDemuxer>();
44 avmetaDataCollector->mediaDemuxer_ = mediaDemuxer;
45 }
46
TearDown(void)47 void AVMetaDataCollectorUnitTest::TearDown(void)
48 {
49 avmetaDataCollector->Destroy();
50 avmetaDataCollector = nullptr;
51 mediaDemuxer = nullptr;
52 }
53
54 /**
55 * @tc.name: ExtractMetadata
56 * @tc.desc: ExtractMetadata
57 * @tc.type: FUNC
58 */
59 HWTEST_F(AVMetaDataCollectorUnitTest, ExtractMetadata, TestSize.Level1)
60 {
61 std::shared_ptr<Meta> globalMeta = std::make_shared<Meta>();
62 std::shared_ptr<Meta> videoMeta = std::make_shared<Meta>();
63 std::shared_ptr<Meta> imageMeta = std::make_shared<Meta>();
64 std::vector<std::shared_ptr<Meta>> trackInfos;
65 EXPECT_CALL(*mediaDemuxer, GetGlobalMetaInfo()).WillRepeatedly(Return(nullptr));
66 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
67 EXPECT_TRUE(avmetaDataCollector->ExtractMetadata().size() == 0);
68
69 globalMeta->SetData(Tag::MEDIA_ALBUM, "media");
70 globalMeta->SetData(Tag::MEDIA_ALBUM_ARTIST, "media_test");
71 globalMeta->SetData(Tag::MEDIA_ARTIST, "元数据测试");
72 globalMeta->SetData(Tag::MEDIA_AUTHOR, "");
73 globalMeta->SetData(Tag::MEDIA_COMPOSER, "测试");
74 globalMeta->SetData(Tag::MEDIA_DURATION, 10030000);
75 globalMeta->SetData(Tag::MEDIA_GENRE, "Lyrical");
76 globalMeta->SetData(Tag::MEDIA_HAS_AUDIO, true);
77 globalMeta->SetData(Tag::MEDIA_HAS_VIDEO, true);
78 globalMeta->SetData(Tag::MEDIA_TITLE, "test");
79 globalMeta->SetData(Tag::MEDIA_TRACK_COUNT, "3");
80 globalMeta->SetData(Tag::MEDIA_DATE, "2022");
81 globalMeta->SetData(Tag::MEDIA_FILE_TYPE, Plugins::FileType::MP4);
82
83 videoMeta->SetData(Tag::VIDEO_ROTATION, Plugins::VideoRotation::VIDEO_ROTATION_0);
84 videoMeta->SetData(Tag::VIDEO_ORIENTATION_TYPE, Plugins::VideoOrientationType::ROTATE_NONE);
85 videoMeta->SetData(Tag::VIDEO_HEIGHT, "480");
86 videoMeta->SetData(Tag::VIDEO_WIDTH, "720");
87 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
88
89 imageMeta->SetData(Tag::MIME_TYPE, "image");
90
91 trackInfos.push_back(videoMeta);
92 trackInfos.push_back(imageMeta);
93 trackInfos.push_back(nullptr);
94
95 EXPECT_CALL(*mediaDemuxer, GetGlobalMetaInfo()).WillRepeatedly(Return(globalMeta));
96 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
97 avmetaDataCollector->ExtractMetadata();
98 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() != 0);
99 avmetaDataCollector->ExtractMetadata();
100 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() != 0);
101 }
102
103 /**
104 * @tc.name: GetAVMetadata
105 * @tc.desc: GetAVMetadata
106 * @tc.type: FUNC
107 */
108 HWTEST_F(AVMetaDataCollectorUnitTest, GetAVMetadata, TestSize.Level1)
109 {
110 avmetaDataCollector->collectedMeta_ = {
111 {AV_KEY_ALBUM, "media"},
112 {AV_KEY_LOCATION_LATITUDE, "test"},
113 {AV_KEY_LOCATION_LONGITUDE, "test"},
114 {AV_KEY_VIDEO_IS_HDR_VIVID, "yes"},
115 {10086, "test"},
116 };
117 std::shared_ptr<Meta> customerInfo = std::make_shared<Meta>();
118 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(nullptr));
119 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
120
121 avmetaDataCollector->collectedAVMetaData_ = nullptr;
122 avmetaDataCollector->collectedMeta_[AV_KEY_VIDEO_IS_HDR_VIVID] = "";
123 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(customerInfo));
124 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
125 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(customerInfo));
126 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
127
128 EXPECT_CALL(*mediaDemuxer, Reset());
129 avmetaDataCollector->Reset();
130 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() == 0);
131 }
132
133 /**
134 * @tc.name: GetArtPicture
135 * @tc.desc: GetArtPicture
136 * @tc.type: FUNC
137 */
138 HWTEST_F(AVMetaDataCollectorUnitTest, GetArtPicture, TestSize.Level1)
139 {
140 std::shared_ptr<Meta> videoMeta = std::make_shared<Meta>();
141 std::shared_ptr<Meta> imageMeta = std::make_shared<Meta>();
142 std::vector<std::shared_ptr<Meta>> trackInfos;
143 std::vector<uint8_t> coverAddr;
144 trackInfos.push_back(nullptr);
145 coverAddr.push_back(1);
146 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
147 videoMeta->SetData(Tag::MEDIA_COVER, coverAddr);
148 imageMeta->SetData(Tag::MIME_TYPE, "image");
149 trackInfos.push_back(videoMeta);
150 trackInfos.push_back(imageMeta);
151
152 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillOnce(Return(trackInfos));
153 EXPECT_TRUE(avmetaDataCollector->GetArtPicture() != nullptr);
154 EXPECT_TRUE(avmetaDataCollector->GetArtPicture() != nullptr);
155 }
156
157 /**
158 * @tc.name: ExtractMetadataByKey
159 * @tc.desc: ExtractMetadataByKey
160 * @tc.type: FUNC
161 */
162 HWTEST_F(AVMetaDataCollectorUnitTest, ExtractMetadataByKey, TestSize.Level1)
163 {
164 avmetaDataCollector->collectedAVMetaData_ = {};
165 avmetaDataCollector->collectedMeta_ = {
166 {AV_KEY_ALBUM, "media"},
167 {AV_KEY_ALBUM_ARTIST, ""},
168 };
169
170 std::string value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM);
171 EXPECT_EQ(value, "media");
172 value = avmetaDataCollector->ExtractMetadata(-1);
173 EXPECT_EQ(value, "");
174 value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM_ARTIST);
175 EXPECT_EQ(value, "");
176
177 avmetaDataCollector->collectedMeta_.clear();
178 value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM);
179 EXPECT_EQ(value, "");
180 }
181
182 /**
183 * @tc.name: GetVideoTrackId
184 * @tc.desc: GetVideoTrackId
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AVMetaDataCollectorUnitTest, GetVideoTrackId, TestSize.Level1)
188 {
189 uint32_t trackId = 0;
190 std::vector<std::shared_ptr<Meta>> trackInfos;
191 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
192 Status ret = avmetaDataCollector->GetVideoTrackId(trackId);
193 EXPECT_EQ(ret, Status::ERROR_INVALID_DATA);
194
195 std::shared_ptr<Meta> imageMeta = std::make_shared<Meta>();
196 imageMeta->SetData(Tag::MIME_TYPE, "image");
197 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
198 imageMeta->SetData(Tag::MIME_TYPE, "image");
199 trackInfos.push_back(imageMeta);
200 trackInfos.push_back(meta);
201 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
202 ret = avmetaDataCollector->GetVideoTrackId(trackId);
203 EXPECT_EQ(ret, Status::ERROR_INVALID_DATA);
204
205 std::shared_ptr<Meta> videoMeta = std::make_shared<Meta>();
206 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
207 trackInfos.push_back(videoMeta);
208 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
209 ret = avmetaDataCollector->GetVideoTrackId(trackId);
210 EXPECT_EQ(ret, Status::OK);
211 }
212
213 /**
214 * @tc.name: GetTimeByFrameIndex
215 * @tc.desc: GetTimeByFrameIndex
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AVMetaDataCollectorUnitTest, GetTimeByFrameIndex, TestSize.Level1)
219 {
220 uint32_t index = 0;
221 uint64_t timeUs = 0;
222 int32_t ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
223 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
224 avmetaDataCollector->hasVideo_ = true;
225 avmetaDataCollector->videoTrackId_ = 0;
226 EXPECT_CALL(*mediaDemuxer, GetRelativePresentationTimeUsByIndex(_, _, _))
227 .WillRepeatedly(Return(Status::ERROR_INVALID_DATA));
228 ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
229 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
230 EXPECT_CALL(*mediaDemuxer, GetRelativePresentationTimeUsByIndex(_, _, _)).WillRepeatedly(Return(Status::OK));
231 ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
232 EXPECT_EQ(ret, MSERR_OK);
233 }
234
235 /**
236 * @tc.name: GetFrameIndexByTime
237 * @tc.desc: GetFrameIndexByTime
238 * @tc.type: FUNC
239 */
240 HWTEST_F(AVMetaDataCollectorUnitTest, GetFrameIndexByTime, TestSize.Level1)
241 {
242 uint32_t index = 0;
243 uint64_t timeUs = 0;
244 int32_t ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
245 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
246 avmetaDataCollector->hasVideo_ = true;
247 avmetaDataCollector->videoTrackId_ = 0;
248 EXPECT_CALL(*mediaDemuxer, GetIndexByRelativePresentationTimeUs(_, _, _))
249 .WillRepeatedly(Return(Status::ERROR_INVALID_DATA));
250 ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
251 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
252 EXPECT_CALL(*mediaDemuxer, GetIndexByRelativePresentationTimeUs(_, _, _)).WillRepeatedly(Return(Status::OK));
253 ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
254 EXPECT_EQ(ret, MSERR_OK);
255 }
256
257 /**
258 * @tc.name: FormatMimeType
259 * @tc.desc: FormatMimeType
260 * @tc.type: FUNC
261 */
262 HWTEST_F(AVMetaDataCollectorUnitTest, FormatMimeType, TestSize.Level1)
263 {
264 Metadata avmeta;
265 std::shared_ptr<Meta> globalInfo = make_shared<Meta>();
266 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, Plugins::FileType::UNKNOW);
267 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
268 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
269
270 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, "test");
271
272 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
273 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
274
275 avmeta.SetMeta(AV_KEY_HAS_AUDIO, "");
276 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, Plugins::FileType::MP4);
277 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
278 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
279 }
280
281 /**
282 * @tc.name: FormatDateTime
283 * @tc.desc: FormatDateTime
284 * @tc.type: FUNC
285 */
286 HWTEST_F(AVMetaDataCollectorUnitTest, FormatDateTime, TestSize.Level1)
287 {
288 Metadata avmeta;
289 std::shared_ptr<Meta> globalInfo = make_shared<Meta>();
290 globalInfo->SetData(Tag::MEDIA_CREATION_TIME, "2022");
291 avmetaDataCollector->FormatDateTime(avmeta, globalInfo);
292 EXPECT_TRUE(avmeta.HasMeta(AV_KEY_DATE_TIME));
293 }
294
295 /**
296 * @tc.name: FormatVideoRotateOrientation
297 * @tc.desc: FormatVideoRotateOrientation
298 * @tc.type: FUNC
299 */
300 HWTEST_F(AVMetaDataCollectorUnitTest, FormatVideoRotateOrientation, TestSize.Level1)
301 {
302 Metadata avmeta;
303 avmeta.SetMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION, "");
304 avmetaDataCollector->FormatVideoRotateOrientation(avmeta);
305 EXPECT_TRUE(avmeta.HasMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION));
306
307 avmeta.SetMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION, "a");
308 avmetaDataCollector->FormatVideoRotateOrientation(avmeta);
309 EXPECT_TRUE(avmeta.HasMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION));
310
311 avmeta.SetMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION, "12345");
312 avmetaDataCollector->FormatVideoRotateOrientation(avmeta);
313 EXPECT_TRUE(avmeta.HasMeta(AV_KEY_VIDEO_ROTATE_ORIENTATION));
314 }
315
316 /**
317 * @tc.name: ConvertToAVMeta
318 * @tc.desc: ConvertToAVMeta
319 * @tc.type: FUNC
320 */
321 HWTEST_F(AVMetaDataCollectorUnitTest, ConvertToAVMeta, TestSize.Level1)
322 {
323 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
324 meta->SetData(Tag::MEDIA_ALBUM, "media");
325 meta->SetData(Tag::MEDIA_ALBUM_ARTIST, "media_test");
326 meta->SetData(Tag::MEDIA_ARTIST, "元数据测试");
327 meta->SetData(Tag::MEDIA_AUTHOR, "");
328 meta->SetData(Tag::MEDIA_COMPOSER, "测试");
329 int64_t duration = 10030000;
330 meta->SetData(Tag::MEDIA_DURATION, duration);
331 meta->SetData(Tag::MEDIA_GENRE, "Lyrical");
332 bool hasAudio = true;
333 meta->SetData(Tag::MEDIA_HAS_AUDIO, hasAudio);
334 meta->SetData(Tag::MEDIA_HAS_VIDEO, "yes");
335 meta->SetData(Tag::MIME_TYPE, "video/mp4");
336 meta->SetData(Tag::MEDIA_TRACK_COUNT, "2");
337 int32_t rate = 44100;
338 meta->SetData(Tag::AUDIO_SAMPLE_RATE, rate);
339 meta->SetData(Tag::MEDIA_TITLE, "test");
340 meta->SetData(Tag::VIDEO_HEIGHT, "480");
341 meta->SetData(Tag::VIDEO_WIDTH, "720");
342 meta->SetData(Tag::MEDIA_DATE, "2022");
343 meta->SetData(Tag::VIDEO_ROTATION, Plugins::VideoRotation::VIDEO_ROTATION_0);
344
345 Metadata avmeta;
346 avmetaDataCollector->ConvertToAVMeta(meta, avmeta);
347 EXPECT_FALSE(avmeta.tbl_.size() == 0);
348 }
349
350 /**
351 * @tc.name: SetStringByValueType
352 * @tc.desc: SetStringByValueType
353 * @tc.type: FUNC
354 */
355 HWTEST_F(AVMetaDataCollectorUnitTest, SetStringByValueType, TestSize.Level1)
356 {
357 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
358 Metadata avmeta;
359 int32_t trackCount = 0;
360 meta->SetData(Tag::MEDIA_TRACK_COUNT, trackCount);
361 float height = 480;
362 meta->SetData(Tag::VIDEO_HEIGHT, height);
363
364 bool ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_NUM_TRACKS, Tag::MEDIA_TRACK_COUNT);
365 EXPECT_TRUE(ret);
366 ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_VIDEO_HEIGHT, Tag::VIDEO_HEIGHT);
367 EXPECT_TRUE(ret);
368 avmetaDataCollector->collectedAVMetaData_ = std::make_shared<Meta>();
369 ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_VIDEO_HEIGHT, Tag::VIDEO_HEIGHT);
370 EXPECT_TRUE(ret);
371 }
372
373 /**
374 * @tc.name: GetVideoTrackInfo_001
375 * @tc.desc: GetVideoTrackInfo_001
376 * @tc.type: FUNC
377 */
378 HWTEST_F(AVMetaDataCollectorUnitTest, GetVideoTrackInfo_001, TestSize.Level1)
379 {
380 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
381 std::string mime = "video/avc";
382 size_t index = 0;
383 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
384 double frameRate = 0;
385 bool ret = meta->GetData(Tag::VIDEO_FRAME_RATE, frameRate);
386 EXPECT_FALSE(ret);
387 avmetaDataCollector->GetVideoTrackInfo(meta, mime, index);
388 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
389 }
390
391 /**
392 * @tc.name: GetVideoTrackInfo_002
393 * @tc.desc: GetVideoTrackInfo_002
394 * @tc.type: FUNC
395 */
396 HWTEST_F(AVMetaDataCollectorUnitTest, GetVideoTrackInfo_002, TestSize.Level1)
397 {
398 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
399 std::string mime = "video/avc";
400 size_t index = 0;
401 double rate = 1;
402 meta->SetData(Tag::VIDEO_FRAME_RATE, rate);
403 double frameRate = 0;
404 bool ret = meta->GetData(Tag::VIDEO_FRAME_RATE, frameRate);
405 EXPECT_TRUE(ret);
406 EXPECT_EQ(frameRate, rate);
407 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
408 avmetaDataCollector->GetVideoTrackInfo(meta, mime, index);
409 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
410 }
411
412 /**
413 * @tc.name: GetSarVideoWidth_001
414 * @tc.desc: GetSarVideoWidth_001
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AVMetaDataCollectorUnitTest, GetSarVideoWidth_001, TestSize.Level1)
418 {
419 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
420 std::string mime = "video/avc";
421 meta->SetData(Tag::VIDEO_WIDTH, 100);
422 meta->SetData(Tag::VIDEO_HEIGHT, 100);
423 double videoSar = 0;
424 bool ret = meta->GetData(Tag::VIDEO_SAR, videoSar);
425 EXPECT_FALSE(ret);
426 EXPECT_EQ(avmetaDataCollector->GetSarVideoWidth(meta), 100);
427 EXPECT_EQ(avmetaDataCollector->GetSarVideoHeight(meta), 100);
428 }
429
430 /**
431 * @tc.name: GetSarVideoWidth_002
432 * @tc.desc: GetSarVideoWidth_002
433 * @tc.type: FUNC
434 */
435 HWTEST_F(AVMetaDataCollectorUnitTest, GetSarVideoWidth_002, TestSize.Level1)
436 {
437 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
438 std::string mime = "video/avc";
439 meta->SetData(Tag::VIDEO_WIDTH, 100);
440 meta->SetData(Tag::VIDEO_HEIGHT, 100);
441 double sar = 2;
442 meta->SetData(Tag::VIDEO_SAR, sar);
443 double videoSar = 0;
444 bool ret = meta->GetData(Tag::VIDEO_SAR, videoSar);
445 EXPECT_TRUE(ret);
446 EXPECT_EQ(videoSar, sar);
447 EXPECT_EQ(avmetaDataCollector->GetSarVideoWidth(meta), 100);
448 EXPECT_EQ(avmetaDataCollector->GetSarVideoHeight(meta), 50);
449 }
450
451 /**
452 * @tc.name: GetSarVideoWidth_003
453 * @tc.desc: GetSarVideoWidth_003
454 * @tc.type: FUNC
455 */
456 HWTEST_F(AVMetaDataCollectorUnitTest, GetSarVideoWidth_003, TestSize.Level1)
457 {
458 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
459 std::string mime = "video/avc";
460 meta->SetData(Tag::VIDEO_WIDTH, 100);
461 meta->SetData(Tag::VIDEO_HEIGHT, 100);
462 double sar = 0.5;
463 meta->SetData(Tag::VIDEO_SAR, sar);
464 double videoSar = 0;
465 bool ret = meta->GetData(Tag::VIDEO_SAR, videoSar);
466 EXPECT_TRUE(ret);
467 EXPECT_EQ(videoSar, sar);
468 EXPECT_EQ(avmetaDataCollector->GetSarVideoWidth(meta), 50);
469 EXPECT_EQ(avmetaDataCollector->GetSarVideoHeight(meta), 100);
470 }
471
472 /**
473 * @tc.name: GetSarVideoWidth_004
474 * @tc.desc: GetSarVideoWidth_004
475 * @tc.type: FUNC
476 */
477 HWTEST_F(AVMetaDataCollectorUnitTest, GetSarVideoWidth_004, TestSize.Level1)
478 {
479 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
480 std::string mime = "video/avc";
481 meta->SetData(Tag::VIDEO_WIDTH, 100);
482 meta->SetData(Tag::VIDEO_HEIGHT, 100);
483 double sar = 1;
484 meta->SetData(Tag::VIDEO_SAR, sar);
485 double videoSar = 0;
486 bool ret = meta->GetData(Tag::VIDEO_SAR, videoSar);
487 EXPECT_TRUE(ret);
488 EXPECT_EQ(videoSar, sar);
489 EXPECT_EQ(avmetaDataCollector->GetSarVideoWidth(meta), 100);
490 EXPECT_EQ(avmetaDataCollector->GetSarVideoHeight(meta), 100);
491 }
492
493 /**
494 * @tc.name: InitTracksInfoVector_001
495 * @tc.desc: InitTracksInfoVector_001
496 * @tc.type: FUNC
497 */
498 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_001, TestSize.Level1)
499 {
500 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
501 meta->SetData(Tag::MIME_TYPE, "audio/mpeg");
502 size_t index = 0;
503 std::string mime = "";
504 bool ret = meta->GetData(Tag::MIME_TYPE, mime);
505 EXPECT_TRUE(ret);
506 EXPECT_EQ(avmetaDataCollector->IsAudioMime(mime), true);
507 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
508 avmetaDataCollector->InitTracksInfoVector(meta, index);
509 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
510 }
511
512 /**
513 * @tc.name: InitTracksInfoVector_002
514 * @tc.desc: InitTracksInfoVector_002
515 * @tc.type: FUNC
516 */
517 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_002, TestSize.Level1)
518 {
519 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
520 meta->SetData(Tag::MIME_TYPE, "video/avc");
521 size_t index = 0;
522 std::string mime = "";
523 bool ret = meta->GetData(Tag::MIME_TYPE, mime);
524 EXPECT_TRUE(ret);
525 EXPECT_EQ(avmetaDataCollector->IsVideoMime(mime), true);
526 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
527 avmetaDataCollector->InitTracksInfoVector(meta, index);
528 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
529 }
530
531 /**
532 * @tc.name: InitTracksInfoVector_003
533 * @tc.desc: InitTracksInfoVector_003
534 * @tc.type: FUNC
535 */
536 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_003, TestSize.Level1)
537 {
538 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
539 meta->SetData(Tag::MIME_TYPE, "application/x-subrip");
540 size_t index = 0;
541 std::string mime = "";
542 bool ret = meta->GetData(Tag::MIME_TYPE, mime);
543 EXPECT_TRUE(ret);
544 EXPECT_EQ(avmetaDataCollector->IsSubtitleMime(mime), true);
545 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
546 avmetaDataCollector->InitTracksInfoVector(meta, index);
547 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
548 }
549
550 /**
551 * @tc.name: InitTracksInfoVector_004
552 * @tc.desc: InitTracksInfoVector_004
553 * @tc.type: FUNC
554 */
555 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_004, TestSize.Level1)
556 {
557 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
558 meta->SetData(Tag::MIME_TYPE, "text/vtt");
559 size_t index = 0;
560 std::string mime = "";
561 bool ret = meta->GetData(Tag::MIME_TYPE, mime);
562 EXPECT_TRUE(ret);
563 EXPECT_EQ(avmetaDataCollector->IsSubtitleMime(mime), true);
564 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
565 avmetaDataCollector->InitTracksInfoVector(meta, index);
566 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
567 }
568
569 /**
570 * @tc.name: InitTracksInfoVector_005
571 * @tc.desc: InitTracksInfoVector_005
572 * @tc.type: FUNC
573 */
574 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_005, TestSize.Level1)
575 {
576 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
577 meta->SetData(Tag::MIME_TYPE, "invalid");
578 size_t index = 0;
579 std::string mime = "";
580 bool ret = meta->GetData(Tag::MIME_TYPE, mime);
581 EXPECT_TRUE(ret);
582 EXPECT_EQ(avmetaDataCollector->IsSubtitleMime(mime), false);
583 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
584 avmetaDataCollector->InitTracksInfoVector(meta, index);
585 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
586 }
587
588 /**
589 * @tc.name: InitTracksInfoVector_006
590 * @tc.desc: InitTracksInfoVector_006
591 * @tc.type: FUNC
592 */
593 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_006, TestSize.Level1)
594 {
595 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
596 meta->SetData(Tag::MEDIA_TYPE, Plugins::MediaType::AUXILIARY);
597 size_t index = 0;
598 Plugins::MediaType mediaType;
599 bool ret = meta->GetData(Tag::MEDIA_TYPE, mediaType);
600 EXPECT_TRUE(ret);
601 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
602 avmetaDataCollector->InitTracksInfoVector(meta, index);
603 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
604 }
605
606 /**
607 * @tc.name: InitTracksInfoVector_007
608 * @tc.desc: InitTracksInfoVector_007
609 * @tc.type: FUNC
610 */
611 HWTEST_F(AVMetaDataCollectorUnitTest, InitTracksInfoVector_007, TestSize.Level1)
612 {
613 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
614 meta->SetData(Tag::MEDIA_TYPE, Plugins::MediaType::TIMEDMETA);
615 size_t index = 0;
616 Plugins::MediaType mediaType;
617 bool ret = meta->GetData(Tag::MEDIA_TYPE, mediaType);
618 EXPECT_TRUE(ret);
619 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 0);
620 avmetaDataCollector->InitTracksInfoVector(meta, index);
621 EXPECT_EQ(avmetaDataCollector->trackInfoVec_.size(), 1);
622 }
623 } // namespace Test
624 } // namespace Media
625 } // namespace OHOS