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_HEIGHT, "480");
85 videoMeta->SetData(Tag::VIDEO_WIDTH, "720");
86 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
87
88 imageMeta->SetData(Tag::MIME_TYPE, "image");
89
90 trackInfos.push_back(videoMeta);
91 trackInfos.push_back(imageMeta);
92 trackInfos.push_back(nullptr);
93
94 EXPECT_CALL(*mediaDemuxer, GetGlobalMetaInfo()).WillRepeatedly(Return(globalMeta));
95 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
96 avmetaDataCollector->ExtractMetadata();
97 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() != 0);
98 avmetaDataCollector->ExtractMetadata();
99 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() != 0);
100 }
101
102 /**
103 * @tc.name: GetAVMetadata
104 * @tc.desc: GetAVMetadata
105 * @tc.type: FUNC
106 */
107 HWTEST_F(AVMetaDataCollectorUnitTest, GetAVMetadata, TestSize.Level1)
108 {
109 avmetaDataCollector->collectedMeta_ = {
110 {AV_KEY_ALBUM, "media"},
111 {AV_KEY_LOCATION_LATITUDE, "test"},
112 {AV_KEY_LOCATION_LONGITUDE, "test"},
113 {AV_KEY_VIDEO_IS_HDR_VIVID, "yes"},
114 {10086, "test"},
115 };
116 std::shared_ptr<Meta> customerInfo = std::make_shared<Meta>();
117 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(nullptr));
118 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
119
120 avmetaDataCollector->collectedAVMetaData_ = nullptr;
121 avmetaDataCollector->collectedMeta_[AV_KEY_VIDEO_IS_HDR_VIVID] = "";
122 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(customerInfo));
123 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
124 EXPECT_CALL(*mediaDemuxer, GetUserMeta()).WillRepeatedly(Return(customerInfo));
125 EXPECT_TRUE(avmetaDataCollector->GetAVMetadata() != nullptr);
126
127 EXPECT_CALL(*mediaDemuxer, Reset());
128 avmetaDataCollector->Reset();
129 EXPECT_TRUE(avmetaDataCollector->collectedMeta_.size() == 0);
130 }
131
132 /**
133 * @tc.name: GetArtPicture
134 * @tc.desc: GetArtPicture
135 * @tc.type: FUNC
136 */
137 HWTEST_F(AVMetaDataCollectorUnitTest, GetArtPicture, TestSize.Level1)
138 {
139 std::shared_ptr<Meta> videoMeta = std::make_shared<Meta>();
140 std::shared_ptr<Meta> imageMeta = std::make_shared<Meta>();
141 std::vector<std::shared_ptr<Meta>> trackInfos;
142 std::vector<uint8_t> coverAddr;
143 trackInfos.push_back(nullptr);
144 coverAddr.push_back(1);
145 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
146 videoMeta->SetData(Tag::MEDIA_COVER, coverAddr);
147 imageMeta->SetData(Tag::MIME_TYPE, "image");
148 trackInfos.push_back(videoMeta);
149 trackInfos.push_back(imageMeta);
150
151 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillOnce(Return(trackInfos));
152 EXPECT_TRUE(avmetaDataCollector->GetArtPicture() != nullptr);
153 EXPECT_TRUE(avmetaDataCollector->GetArtPicture() != nullptr);
154 }
155
156 /**
157 * @tc.name: ExtractMetadataByKey
158 * @tc.desc: ExtractMetadataByKey
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AVMetaDataCollectorUnitTest, ExtractMetadataByKey, TestSize.Level1)
162 {
163 avmetaDataCollector->collectedAVMetaData_ = {};
164 avmetaDataCollector->collectedMeta_ = {
165 {AV_KEY_ALBUM, "media"},
166 {AV_KEY_ALBUM_ARTIST, ""},
167 };
168
169 std::string value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM);
170 EXPECT_EQ(value, "media");
171 value = avmetaDataCollector->ExtractMetadata(-1);
172 EXPECT_EQ(value, "");
173 value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM_ARTIST);
174 EXPECT_EQ(value, "");
175
176 avmetaDataCollector->collectedMeta_.clear();
177 value = avmetaDataCollector->ExtractMetadata(AV_KEY_ALBUM);
178 EXPECT_EQ(value, "");
179 }
180
181 /**
182 * @tc.name: GetVideoTrackId
183 * @tc.desc: GetVideoTrackId
184 * @tc.type: FUNC
185 */
186 HWTEST_F(AVMetaDataCollectorUnitTest, GetVideoTrackId, TestSize.Level1)
187 {
188 uint32_t trackId = 0;
189 std::vector<std::shared_ptr<Meta>> trackInfos;
190 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
191 Status ret = avmetaDataCollector->GetVideoTrackId(trackId);
192 EXPECT_EQ(ret, Status::ERROR_INVALID_DATA);
193
194 std::shared_ptr<Meta> imageMeta = std::make_shared<Meta>();
195 imageMeta->SetData(Tag::MIME_TYPE, "image");
196 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
197 imageMeta->SetData(Tag::MIME_TYPE, "image");
198 trackInfos.push_back(imageMeta);
199 trackInfos.push_back(meta);
200 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
201 ret = avmetaDataCollector->GetVideoTrackId(trackId);
202 EXPECT_EQ(ret, Status::ERROR_INVALID_DATA);
203
204 std::shared_ptr<Meta> videoMeta = std::make_shared<Meta>();
205 videoMeta->SetData(Tag::MIME_TYPE, "video/mp4");
206 trackInfos.push_back(videoMeta);
207 EXPECT_CALL(*mediaDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(trackInfos));
208 ret = avmetaDataCollector->GetVideoTrackId(trackId);
209 EXPECT_EQ(ret, Status::OK);
210 }
211
212 /**
213 * @tc.name: GetTimeByFrameIndex
214 * @tc.desc: GetTimeByFrameIndex
215 * @tc.type: FUNC
216 */
217 HWTEST_F(AVMetaDataCollectorUnitTest, GetTimeByFrameIndex, TestSize.Level1)
218 {
219 uint32_t index = 0;
220 uint64_t timeUs = 0;
221 int32_t ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
222 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
223 avmetaDataCollector->hasVideo_ = true;
224 avmetaDataCollector->videoTrackId_ = 0;
225 EXPECT_CALL(*mediaDemuxer, GetRelativePresentationTimeUsByIndex(_, _, _))
226 .WillRepeatedly(Return(Status::ERROR_INVALID_DATA));
227 ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
228 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
229 EXPECT_CALL(*mediaDemuxer, GetRelativePresentationTimeUsByIndex(_, _, _)).WillRepeatedly(Return(Status::OK));
230 ret = avmetaDataCollector->GetTimeByFrameIndex(index, timeUs);
231 EXPECT_EQ(ret, MSERR_OK);
232 }
233
234 /**
235 * @tc.name: GetFrameIndexByTime
236 * @tc.desc: GetFrameIndexByTime
237 * @tc.type: FUNC
238 */
239 HWTEST_F(AVMetaDataCollectorUnitTest, GetFrameIndexByTime, TestSize.Level1)
240 {
241 uint32_t index = 0;
242 uint64_t timeUs = 0;
243 int32_t ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
244 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
245 avmetaDataCollector->hasVideo_ = true;
246 avmetaDataCollector->videoTrackId_ = 0;
247 EXPECT_CALL(*mediaDemuxer, GetIndexByRelativePresentationTimeUs(_, _, _))
248 .WillRepeatedly(Return(Status::ERROR_INVALID_DATA));
249 ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
250 EXPECT_EQ(ret, MSERR_UNSUPPORT_FILE);
251 EXPECT_CALL(*mediaDemuxer, GetIndexByRelativePresentationTimeUs(_, _, _)).WillRepeatedly(Return(Status::OK));
252 ret = avmetaDataCollector->GetFrameIndexByTime(timeUs, index);
253 EXPECT_EQ(ret, MSERR_OK);
254 }
255
256 /**
257 * @tc.name: FormatMimeType
258 * @tc.desc: FormatMimeType
259 * @tc.type: FUNC
260 */
261 HWTEST_F(AVMetaDataCollectorUnitTest, FormatMimeType, TestSize.Level1)
262 {
263 Metadata avmeta;
264 std::shared_ptr<Meta> globalInfo = make_shared<Meta>();
265 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, Plugins::FileType::UNKNOW);
266 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
267 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
268
269 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, "test");
270
271 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
272 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
273
274 avmeta.SetMeta(AV_KEY_HAS_AUDIO, "");
275 globalInfo->SetData(Tag::MEDIA_FILE_TYPE, Plugins::FileType::MP4);
276 avmetaDataCollector->FormatMimeType(avmeta, globalInfo);
277 EXPECT_FALSE(avmeta.HasMeta(AV_KEY_MIME_TYPE));
278 }
279
280 /**
281 * @tc.name: FormatDateTime
282 * @tc.desc: FormatDateTime
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AVMetaDataCollectorUnitTest, FormatDateTime, TestSize.Level1)
286 {
287 Metadata avmeta;
288 std::shared_ptr<Meta> globalInfo = make_shared<Meta>();
289 globalInfo->SetData(Tag::MEDIA_CREATION_TIME, "2022");
290 avmetaDataCollector->FormatDateTime(avmeta, globalInfo);
291 EXPECT_TRUE(avmeta.HasMeta(AV_KEY_DATE_TIME));
292 }
293
294 /**
295 * @tc.name: ConvertToAVMeta
296 * @tc.desc: ConvertToAVMeta
297 * @tc.type: FUNC
298 */
299 HWTEST_F(AVMetaDataCollectorUnitTest, ConvertToAVMeta, TestSize.Level1)
300 {
301 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
302 meta->SetData(Tag::MEDIA_ALBUM, "media");
303 meta->SetData(Tag::MEDIA_ALBUM_ARTIST, "media_test");
304 meta->SetData(Tag::MEDIA_ARTIST, "元数据测试");
305 meta->SetData(Tag::MEDIA_AUTHOR, "");
306 meta->SetData(Tag::MEDIA_COMPOSER, "测试");
307 int64_t duration = 10030000;
308 meta->SetData(Tag::MEDIA_DURATION, duration);
309 meta->SetData(Tag::MEDIA_GENRE, "Lyrical");
310 bool hasAudio = true;
311 meta->SetData(Tag::MEDIA_HAS_AUDIO, hasAudio);
312 meta->SetData(Tag::MEDIA_HAS_VIDEO, "yes");
313 meta->SetData(Tag::MIME_TYPE, "video/mp4");
314 meta->SetData(Tag::MEDIA_TRACK_COUNT, "2");
315 int32_t rate = 44100;
316 meta->SetData(Tag::AUDIO_SAMPLE_RATE, rate);
317 meta->SetData(Tag::MEDIA_TITLE, "test");
318 meta->SetData(Tag::VIDEO_HEIGHT, "480");
319 meta->SetData(Tag::VIDEO_WIDTH, "720");
320 meta->SetData(Tag::MEDIA_DATE, "2022");
321 meta->SetData(Tag::VIDEO_ROTATION, Plugins::VideoRotation::VIDEO_ROTATION_0);
322
323 Metadata avmeta;
324 avmetaDataCollector->ConvertToAVMeta(meta, avmeta);
325 EXPECT_FALSE(avmeta.tbl_.size() == 0);
326 }
327
328 /**
329 * @tc.name: SetStringByValueType
330 * @tc.desc: SetStringByValueType
331 * @tc.type: FUNC
332 */
333 HWTEST_F(AVMetaDataCollectorUnitTest, SetStringByValueType, TestSize.Level1)
334 {
335 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
336 Metadata avmeta;
337 int32_t trackCount = 0;
338 meta->SetData(Tag::MEDIA_TRACK_COUNT, trackCount);
339 float height = 480;
340 meta->SetData(Tag::VIDEO_HEIGHT, height);
341
342 bool ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_NUM_TRACKS, Tag::MEDIA_TRACK_COUNT);
343 EXPECT_TRUE(ret);
344 ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_VIDEO_HEIGHT, Tag::VIDEO_HEIGHT);
345 EXPECT_TRUE(ret);
346 avmetaDataCollector->collectedAVMetaData_ = std::make_shared<Meta>();
347 ret = avmetaDataCollector->SetStringByValueType(meta, avmeta, AV_KEY_VIDEO_HEIGHT, Tag::VIDEO_HEIGHT);
348 EXPECT_TRUE(ret);
349 }
350
351 } // namespace Test
352 } // namespace Media
353 } // namespace OHOS