1 /*
2 * Copyright (c) 2023 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 #include "medialibrary_thumbnail_fuzzer.h"
16
17 #include <cstdint>
18 #include <string>
19 #include <pixel_map.h>
20 #include <fstream>
21 #include <fuzzer/FuzzedDataProvider.h>
22
23 #include "ability_context_impl.h"
24 #include "abs_rdb_predicates.h"
25 #include "cloud_thumbnail_observer.h"
26 #include "datashare_helper.h"
27 #include "image_type.h"
28 #include "ithumbnail_helper.h"
29 #include "media_column.h"
30 #include "media_file_utils.h"
31 #include "media_log.h"
32 #include "medialibrary_errno.h"
33 #include "medialibrary_data_manager.h"
34 #include "medialibrary_kvstore_manager.h"
35 #include "medialibrary_unistore_manager.h"
36 #include "rdb_predicates.h"
37 #include "userfile_manager_types.h"
38
39 #define private public
40 #include "thumbnail_aging_helper.h"
41 #include "thumbnail_file_utils.h"
42 #include "thumbnail_generate_helper.h"
43 #include "thumbnail_generate_worker.h"
44 #include "thumbnail_generate_worker_manager.h"
45 #include "thumbnail_image_framework_utils.h"
46 #include "thumbnail_service.h"
47 #include "thumbnail_source_loading.h"
48 #include "thumbnail_uri_utils.h"
49 #undef private
50
51 namespace OHOS {
52 using namespace std;
53 using namespace DataShare;
54 using namespace DistributedKv;
55 using namespace NativeRdb;
56 using namespace AAFwk;
57 using ChangeType = DataShare::DataShareObserver::ChangeType;
58 using ThumbnailGenerateExecute = void (*)(std::shared_ptr<Media::ThumbnailTaskData> &data);
59 using ThumbnailWorkerPtr = std::shared_ptr<Media::ThumbnailGenerateWorker>;
60 const string PHOTOS_TABLE = "Photos";
61 const string TEST_IMAGE_PATH = "/storage/cloud/files/Photo/1/CreateImageLcdTest_001.jpg";
62 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
63 const int32_t PIXELMAP_WIDTH_AND_HEIGHT = 1000;
64 const int32_t NUM_BYTES = 1;
65 const int32_t REMAINDER_1 = 1;
66 const int32_t REMAINDER_2 = 2;
67 const int32_t REMAINDER_3 = 3;
68 const int32_t REMAINDER_4 = 4;
69 const int32_t MIN_THUMBNAIL_TYPE = -1;
70 const int32_t MIN_TASK_TYPE = -1;
71 const int32_t MIN_TASK_PRIORITY = -1;
72 const int32_t MAX_TASK_TYPE = 1;
73 const int32_t MAX_TASK_PRIORITY = 2;
74 const int32_t MAX_THUMBNAIL_TYPE = 8;
75 const int32_t MAX_PIXEL_FORMAT = 15;
76 const int32_t MAX_MEDIA_TYPE = 14;
77 const int32_t MAX_BYTE_VALUE = 256;
78 const int32_t SEED_SIZE = 1024;
79 FuzzedDataProvider *provider = nullptr;
80
FuzzThumbnailType()81 static inline Media::ThumbnailType FuzzThumbnailType()
82 {
83 int32_t value = provider->ConsumeIntegralInRange<int32_t>(MIN_THUMBNAIL_TYPE, MAX_THUMBNAIL_TYPE);
84 return static_cast<Media::ThumbnailType>(value);
85 }
86
FuzzSize()87 static inline Media::Size FuzzSize()
88 {
89 Media::Size value;
90 value.width = provider->ConsumeIntegral<int32_t>();
91 value.height = provider->ConsumeIntegral<int32_t>();
92 return value;
93 }
94
FuzzPixelFormat()95 static inline Media::PixelFormat FuzzPixelFormat()
96 {
97 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0, MAX_PIXEL_FORMAT);
98 return static_cast<Media::PixelFormat>(value);
99 }
100
FuzzDecodeOptions()101 static inline Media::DecodeOptions FuzzDecodeOptions()
102 {
103 Media::DecodeOptions value;
104 value.desiredPixelFormat = FuzzPixelFormat();
105 return value;
106 }
107
FuzzThumbnailTaskType()108 static inline Media::ThumbnailTaskType FuzzThumbnailTaskType()
109 {
110 int32_t value = provider->ConsumeIntegralInRange<int32_t>(MIN_TASK_TYPE, MAX_TASK_TYPE);
111 return static_cast<Media::ThumbnailTaskType>(value);
112 }
113
FuzzThumbRdbOpt(bool isNeedNullptr)114 static Media::ThumbRdbOpt FuzzThumbRdbOpt(bool isNeedNullptr)
115 {
116 std::shared_ptr<Media::MediaLibraryRdbStore> store;
117 if (isNeedNullptr) {
118 store = provider->ConsumeBool() ?
119 Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore() : nullptr;
120 } else {
121 store = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
122 }
123
124 Media::ThumbRdbOpt opt = {
125 .store = store,
126 .networkId = provider->ConsumeBytesAsString(NUM_BYTES),
127 .path = provider->ConsumeBytesAsString(NUM_BYTES),
128 .table = provider->ConsumeBool() ? PHOTOS_TABLE : provider->ConsumeBytesAsString(NUM_BYTES),
129 .row = provider->ConsumeBytesAsString(NUM_BYTES),
130 .dateTaken = provider->ConsumeBytesAsString(NUM_BYTES),
131 .fileUri = provider->ConsumeBytesAsString(NUM_BYTES)
132 };
133 return opt;
134 }
135
FuzzMediaType()136 static inline Media::MediaType FuzzMediaType()
137 {
138 int32_t value = provider->ConsumeIntegralInRange<int32_t>(0, MAX_MEDIA_TYPE);
139 return static_cast<Media::MediaType>(value);
140 }
141
FuzzThumbnailData()142 static Media::ThumbnailData FuzzThumbnailData()
143 {
144 Media::ThumbnailData datas;
145 datas.path = provider->ConsumeBytesAsString(NUM_BYTES);
146 datas.mediaType = FuzzMediaType();
147 if (provider->ConsumeBool()) {
148 datas.id = to_string(provider->ConsumeIntegral<int32_t>());
149 datas.dateTaken = to_string(provider->ConsumeIntegral<int32_t>());
150 }
151 return datas;
152 }
153
FuzzThumbnailTaskPriority()154 static Media::ThumbnailTaskPriority FuzzThumbnailTaskPriority()
155 {
156 int32_t value = provider->ConsumeIntegralInRange<int32_t>(MIN_TASK_PRIORITY, MAX_TASK_PRIORITY);
157 return static_cast<Media::ThumbnailTaskPriority>(value);
158 }
159
FuzzThumbnailUri(bool isNeedPath)160 static string FuzzThumbnailUri(bool isNeedPath)
161 {
162 if (!provider->ConsumeBool()) {
163 return provider->ConsumeBytesAsString(NUM_BYTES);
164 }
165
166 string thumUri = "file://media/Photo/1?operation=thumbnail";
167 Media::Size value = FuzzSize();
168 thumUri += "&width=" + to_string(value.width) + "&height=" + to_string(value.height);
169 thumUri += "&date_modified=" + to_string(provider->ConsumeIntegral<int64_t>());
170 int32_t thumbType = abs(provider->ConsumeIntegral<int32_t>()) % 4;
171 thumUri += "&type=" + to_string(thumbType);
172 thumUri += "&begin_stamp=" + to_string(provider->ConsumeIntegral<int32_t>());
173 if (isNeedPath) {
174 thumUri += "&path=" + provider->ConsumeBytesAsString(NUM_BYTES);
175 }
176 thumUri += "&date_taken=" + to_string(provider->ConsumeIntegral<int64_t>());
177
178 return thumUri;
179 }
180
CreateTestPixelMap(Media::PixelFormat format,bool useDMA)181 static std::shared_ptr<Media::PixelMap> CreateTestPixelMap(Media::PixelFormat format, bool useDMA)
182 {
183 Media::InitializationOptions opts;
184 opts.size.width = PIXELMAP_WIDTH_AND_HEIGHT;
185 opts.size.height = PIXELMAP_WIDTH_AND_HEIGHT;
186 opts.srcPixelFormat = format;
187 opts.pixelFormat = format;
188 opts.useDMA = useDMA;
189 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opts);
190 return pixelMap;
191 }
192
FuzzNormalPixelMap(bool isNeedNullptr=false)193 static std::shared_ptr<Media::PixelMap> FuzzNormalPixelMap(bool isNeedNullptr = false)
194 {
195 int32_t value = abs(provider->ConsumeIntegral<int32_t>()) % 3;
196 Media::PixelFormat format = Media::PixelFormat::RGBA_8888;
197 bool useDMA = provider->ConsumeBool();
198 if (value == REMAINDER_1) {
199 format = Media::PixelFormat::RGBA_8888;
200 } else if (value == REMAINDER_2) {
201 format = Media::PixelFormat::RGBA_1010102;
202 useDMA = true;
203 } else if (!isNeedNullptr) {
204 format = Media::PixelFormat::RGBA_8888;
205 } else {
206 return nullptr;
207 }
208 return CreateTestPixelMap(format, useDMA);
209 }
210
FuzzYuvPixelMap(bool isNeedNullptr=false)211 static std::shared_ptr<Media::PixelMap> FuzzYuvPixelMap(bool isNeedNullptr = false)
212 {
213 int32_t value = abs(provider->ConsumeIntegral<int32_t>()) % 5;
214 Media::PixelFormat format = Media::PixelFormat::NV12;
215 bool useDMA = provider->ConsumeBool();
216 if (value == REMAINDER_1) {
217 format = Media::PixelFormat::NV12;
218 } else if (value == REMAINDER_2) {
219 format = Media::PixelFormat::NV21;
220 } else if (value == REMAINDER_3) {
221 format = Media::PixelFormat::YCBCR_P010;
222 useDMA = true;
223 } else if (value == REMAINDER_4) {
224 format = Media::PixelFormat::YCRCB_P010;
225 useDMA = true;
226 } else if (!isNeedNullptr) {
227 format = Media::PixelFormat::NV12;
228 } else {
229 return nullptr;
230 }
231 return CreateTestPixelMap(format, useDMA);
232 }
233
FuzzPicture(bool isNeedGainMap,bool isYuv,bool isNeedNullptr=false)234 static std::shared_ptr<Media::Picture> FuzzPicture(bool isNeedGainMap, bool isYuv, bool isNeedNullptr = false)
235 {
236 std::shared_ptr<Media::PixelMap> pixelMap;
237 if (isYuv) {
238 pixelMap = FuzzYuvPixelMap(isNeedNullptr);
239 } else {
240 pixelMap = FuzzNormalPixelMap(isNeedNullptr);
241 }
242 if (pixelMap == nullptr) {
243 return nullptr;
244 }
245
246 auto sourcePtr = Media::Picture::Create(pixelMap);
247 std::shared_ptr<Media::Picture> picture = std::move(sourcePtr);
248 if (!isNeedGainMap) {
249 return picture;
250 }
251
252 std::shared_ptr<Media::PixelMap> gainMap;
253 if (isYuv) {
254 gainMap = FuzzYuvPixelMap(isNeedNullptr);
255 } else {
256 gainMap = FuzzNormalPixelMap(isNeedNullptr);
257 }
258 if (gainMap == nullptr) {
259 return nullptr;
260 }
261
262 Media::Size gainMapSize = {gainMap->GetWidth(), gainMap->GetHeight()};
263 auto auxiliaryPicturePtr = Media::AuxiliaryPicture::Create(gainMap,
264 Media::AuxiliaryPictureType::GAINMAP, gainMapSize);
265 std::shared_ptr<Media::AuxiliaryPicture> auxiliaryPicture = std::move(auxiliaryPicturePtr);
266 CHECK_AND_RETURN_RET_LOG(auxiliaryPicture != nullptr, nullptr, "Create auxiliaryPicture failed");
267 picture->SetAuxiliaryPicture(auxiliaryPicture);
268 return picture;
269 }
270
FuzzThumbnailPath()271 static std::string FuzzThumbnailPath()
272 {
273 std::string path = "/storage/cloud/files/" + to_string(provider->ConsumeIntegral<int32_t>()) + "/fuzztest";
274 Media::ThumbnailData thumbnailData;
275 thumbnailData.path = path;
276 std::string thumbnailDir = Media::ThumbnailFileUtils::GetThumbnailDir(thumbnailData);
277 Media::MediaFileUtils::CreateDirectory(thumbnailDir);
278
279 std::string lcdPath = thumbnailDir + "/LCD.jpg";
280 Media::MediaFileUtils::CreateFile(lcdPath);
281
282 std::string thumbPath = thumbnailDir + "/THM.jpg";
283 Media::MediaFileUtils::CreateFile(thumbPath);
284
285 std::string astcPath = thumbnailDir + "/THM_ASTC.astc";
286 Media::MediaFileUtils::CreateFile(astcPath);
287
288 std::string thumbExDir = thumbnailDir + "/THM_EX";
289 Media::MediaFileUtils::CreateDirectory(thumbExDir);
290 std::string thumbExFile = thumbExDir + "/THM.jpg";
291 Media::MediaFileUtils::CreateFile(thumbExFile);
292 thumbExFile = thumbExDir + "/LCD.jpg";
293 Media::MediaFileUtils::CreateFile(thumbExFile);
294
295 std::string beginTimeStampDir = thumbnailDir + "/beginTimeStampDir0";
296 Media::MediaFileUtils::CreateDirectory(beginTimeStampDir);
297 std::string beginTimeStampFile = beginTimeStampDir + "/THM.jpg";
298 Media::MediaFileUtils::CreateFile(beginTimeStampFile);
299 beginTimeStampFile = beginTimeStampDir + "/LCD.jpg";
300 Media::MediaFileUtils::CreateFile(beginTimeStampFile);
301 return path;
302 }
303
ThumbnailAgingHelperTest()304 static void ThumbnailAgingHelperTest()
305 {
306 Media::ThumbRdbOpt opt = FuzzThumbRdbOpt(false);
307 Media::ThumbnailAgingHelper::AgingLcdBatch(opt);
308 int64_t time = provider->ConsumeIntegral<int64_t>();
309 bool before = provider->ConsumeBool();
310 int outLcdCount;
311 Media::ThumbnailAgingHelper::GetAgingDataCount(time, before, opt, outLcdCount);
312
313 vector<Media::ThumbnailData> infos;
314 Media::ThumbnailAgingHelper::GetAgingLcdData(opt, provider->ConsumeIntegral<int32_t>(), infos);
315 Media::ThumbnailAgingHelper::GetLcdCountByTime(provider->ConsumeIntegral<int64_t>(), provider->ConsumeBool(),
316 opt, outLcdCount);
317 }
318
ThumbnailGenerateHelperTest()319 static void ThumbnailGenerateHelperTest()
320 {
321 Media::ThumbRdbOpt opts = FuzzThumbRdbOpt(true);
322 Media::ThumbnailGenerateHelper::CreateThumbnailFileScaned(opts, provider->ConsumeBool());
323 Media::ThumbnailGenerateHelper::CreateThumbnailBackground(opts);
324 Media::ThumbnailGenerateHelper::CreateAstcBackground(opts);
325 Media::ThumbnailGenerateHelper::CreateAstcCloudDownload(opts, provider->ConsumeBool());
326 Media::ThumbnailGenerateHelper::CreateAstcMthAndYear(opts);
327 RdbPredicates predicates(PHOTOS_TABLE);
328 Media::ThumbnailGenerateHelper::CreateLcdBackground(opts);
329 Media::ThumbnailGenerateHelper::CreateAstcBatchOnDemand(opts, predicates, provider->ConsumeIntegral<int32_t>());
330 Media::ThumbnailGenerateHelper::CheckLcdSizeAndUpdateStatus(opts);
331 int32_t outLcdCount;
332 Media::ThumbnailGenerateHelper::GetLcdCount(opts, outLcdCount);
333 vector<Media::ThumbnailData> outDatas;
334 Media::ThumbnailGenerateHelper::GetNoLcdData(opts, outDatas);
335 outDatas.clear();
336 Media::ThumbnailGenerateHelper::GetNoThumbnailData(opts, outDatas);
337 outDatas.clear();
338 Media::ThumbnailGenerateHelper::GetNoAstcData(opts, outDatas);
339 outDatas.clear();
340 Media::ThumbnailGenerateHelper::GetLocalNoLcdData(opts, outDatas);
341 outDatas.clear();
342 int64_t time = provider->ConsumeIntegral<int64_t>();
343 int32_t count;
344 Media::ThumbnailGenerateHelper::GetNewThumbnailCount(opts, time, count);
345 Media::ThumbnailData thumbData = FuzzThumbnailData();
346 string fileName;
347 int32_t thumbType = abs(provider->ConsumeIntegral<int32_t>()) % 4;
348 int32_t timeStamp = provider->ConsumeIntegral<int32_t>();
349 Media::ThumbnailGenerateHelper::GetAvailableFile(opts, thumbData, FuzzThumbnailType(), fileName);
350 Media::ThumbnailGenerateHelper::GetAvailableKeyFrameFile(opts, thumbData, thumbType, fileName);
351 Media::ThumbnailGenerateHelper::GetThumbnailPixelMap(thumbData, opts, FuzzThumbnailType());
352 Media::ThumbnailGenerateHelper::UpgradeThumbnailBackground(opts, provider->ConsumeBool());
353 Media::ThumbnailGenerateHelper::RestoreAstcDualFrame(opts);
354 outDatas.clear();
355 Media::ThumbnailGenerateHelper::GetThumbnailDataNeedUpgrade(opts, outDatas, provider->ConsumeBool());
356 Media::ThumbnailGenerateHelper::CheckMonthAndYearKvStoreValid(opts);
357 Media::ThumbnailGenerateHelper::GenerateHighlightThumbnailBackground(opts);
358 Media::ThumbRdbOpt optsWithRdb = FuzzThumbRdbOpt(false);
359 if (optsWithRdb.store != nullptr) {
360 outDatas.clear();
361 Media::ThumbnailGenerateHelper::GetNoHighlightData(optsWithRdb, outDatas);
362 outDatas.clear();
363 Media::ThumbnailGenerateHelper::GetKeyFrameThumbnailPixelMap(optsWithRdb, timeStamp, thumbType);
364 Media::ThumbnailGenerateHelper::CreateThumbnailFileScanedWithPicture(
365 optsWithRdb, FuzzPicture(true, true, true), provider->ConsumeBool());
366 }
367 }
368
ThumbnailGenerateWorkerTest()369 static void ThumbnailGenerateWorkerTest()
370 {
371 Media::ThumbRdbOpt opts = FuzzThumbRdbOpt(false);
372 Media::ThumbnailData thumbnailData = FuzzThumbnailData();
373 std::shared_ptr<Media::ThumbnailTaskData> taskData =
374 std::make_shared<Media::ThumbnailTaskData>(opts, thumbnailData, provider->ConsumeIntegral<int32_t>());
375 std::shared_ptr<Media::ThumbnailGenerateTask> task =
376 std::make_shared<Media::ThumbnailGenerateTask>(Media::IThumbnailHelper::CreateLcdAndThumbnail, taskData);
377
378 std::shared_ptr<Media::ThumbnailGenerateWorker> workerPtr = std::make_shared<Media::ThumbnailGenerateWorker>();
379 Media::ThumbnailTaskPriority priority = FuzzThumbnailTaskPriority();
380 workerPtr->AddTask(task, priority);
381 workerPtr->ReleaseTaskQueue(priority);
382 }
383
ThumbnailGenerateWorkerManagerTest()384 static void ThumbnailGenerateWorkerManagerTest()
385 {
386 Media::ThumbnailTaskType type = FuzzThumbnailTaskType();
387 auto& manager = Media::ThumbnailGenerateWorkerManager::GetInstance();
388 manager.InitThumbnailWorker(type);
389 manager.ClearAllTask();
390
391 manager.InitThumbnailWorker(type);
392 manager.TryCloseThumbnailWorkerTimer();
393 }
394
SetTables()395 void SetTables()
396 {
397 vector<string> createTableSqlList = { Media::PhotoColumn::CREATE_PHOTO_TABLE };
398 for (auto &createTableSql : createTableSqlList) {
399 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
400 if (ret != NativeRdb::E_OK) {
401 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
402 return;
403 }
404 MEDIA_DEBUG_LOG("Execute sql %{private}s success", createTableSql.c_str());
405 }
406 }
407
Init()408 static void Init()
409 {
410 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
411 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
412 abilityContextImpl->SetStageContext(stageContext);
413 int32_t sceneCode = 0;
414 auto ret = Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl,
415 abilityContextImpl, sceneCode);
416 CHECK_AND_RETURN_LOG(ret == NativeRdb::E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
417
418 auto rdbStore = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
419 if (rdbStore == nullptr) {
420 MEDIA_ERR_LOG("rdbStore is nullptr");
421 return;
422 }
423 g_rdbStore = rdbStore;
424 SetTables();
425 }
426
Finish()427 static void Finish()
428 {
429 Media::MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
430 }
431
ThumhnailTest()432 static void ThumhnailTest()
433 {
434 Media::ThumbnailService::GetInstance()->GetThumbnailFd(provider->ConsumeBytesAsString(NUM_BYTES),
435 provider->ConsumeIntegral<int32_t>());
436 string thumUri = "file://media/Photo/1?operation=thumbnail&width=-1&height=-1";
437 Media::ThumbnailService::GetInstance()->GetThumbnailFd(thumUri, provider->ConsumeIntegral<int32_t>());
438 Media::ThumbnailService::GetInstance()->LcdAging();
439 Media::ThumbnailService::GetInstance()->CreateThumbnailFileScaned(provider->ConsumeBytesAsString(NUM_BYTES),
440 provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeIntegral<int32_t>());
441 NativeRdb::RdbPredicates rdbPredicate("Photos");
442 Media::ThumbnailService::GetInstance()->CancelAstcBatchTask(provider->ConsumeIntegral<int32_t>());
443 Media::ThumbnailService::GetInstance()->GenerateThumbnailBackground();
444 Media::ThumbnailService::GetInstance()->UpgradeThumbnailBackground(false);
445 Media::ThumbnailService::GetInstance()->RestoreThumbnailDualFrame();
446 Media::ThumbnailService::GetInstance()->CheckCloudThumbnailDownloadFinish();
447 Media::ThumbnailService::GetInstance()->InterruptBgworker();
448 }
449
ThumbnailSourceTest()450 static void ThumbnailSourceTest()
451 {
452 Media::GetLocalThumbnailPath(provider->ConsumeBytesAsString(NUM_BYTES), provider->ConsumeBytesAsString(NUM_BYTES));
453 int32_t error;
454 int32_t minSize = provider->ConsumeIntegral<int32_t>();
455 Media::ThumbnailData thumbnailData = FuzzThumbnailData();
456 Media::LocalThumbSource::GetSourcePath(thumbnailData, error);
457 Media::LocalThumbSource::IsSizeLargeEnough(thumbnailData, minSize);
458 thumbnailData = FuzzThumbnailData();
459 Media::LocalLcdSource::GetSourcePath(thumbnailData, error);
460 Media::LocalLcdSource::IsSizeLargeEnough(thumbnailData, minSize);
461 thumbnailData = FuzzThumbnailData();
462 Media::LocalOriginSource::GetSourcePath(thumbnailData, error);
463 Media::LocalOriginSource::IsSizeLargeEnough(thumbnailData, minSize);
464
465 thumbnailData = FuzzThumbnailData();
466 Media::CloudThumbSource::GetSourcePath(thumbnailData, error);
467 Media::CloudThumbSource::IsSizeLargeEnough(thumbnailData, minSize);
468
469 thumbnailData = FuzzThumbnailData();
470 Media::CloudLcdSource::GetSourcePath(thumbnailData, error);
471 Media::CloudLcdSource::IsSizeLargeEnough(thumbnailData, minSize);
472
473 thumbnailData = FuzzThumbnailData();
474 Media::CloudOriginSource::GetSourcePath(thumbnailData, error);
475 Media::CloudOriginSource::IsSizeLargeEnough(thumbnailData, minSize);
476 Media::NeedAutoResize(FuzzSize());
477
478 Media::DecodeOptions decodeOpts = FuzzDecodeOptions();
479 Media::GenDecodeOpts(FuzzSize(), FuzzSize(), decodeOpts);
480
481 thumbnailData = FuzzThumbnailData();
482 Media::Size sourceSize = FuzzSize();
483 Media::Size desiredSize = FuzzSize();
484 Media::ConvertDecodeSize(thumbnailData, sourceSize, desiredSize);
485 uint32_t err = 0;
486 Media::LoadImageSource(provider->ConsumeBytesAsString(NUM_BYTES), err);
487 }
488
ThumbnailSourceTest2()489 static void ThumbnailSourceTest2()
490 {
491 Media::Size desiredSize = FuzzSize();
492 Media::ThumbnailData thumbnailData = FuzzThumbnailData();
493 Media::SourceLoader sourceLoader(desiredSize, thumbnailData);
494 sourceLoader.CreateVideoFramePixelMap();
495 sourceLoader.SetCurrentStateFunction();
496
497 thumbnailData = FuzzThumbnailData();
498 thumbnailData.originalPhotoPicture = FuzzPicture(true, true, true);
499 Media::SourceLoader sourceLoader2(desiredSize, thumbnailData);
500 sourceLoader2.RunLoading();
501 thumbnailData = FuzzThumbnailData();
502 thumbnailData.originalPhotoPicture = FuzzPicture(false, false, true);
503 Media::SourceLoader sourceLoader3(desiredSize, thumbnailData);
504 sourceLoader3.CreateSourceFromOriginalPhotoPicture();
505
506 thumbnailData = FuzzThumbnailData();
507 thumbnailData.originalPhotoPicture = FuzzPicture(true, false, true);
508 Media::SourceLoader sourceLoader4(desiredSize, thumbnailData);
509 sourceLoader4.CreateSourceWithWholeOriginalPicture();
510
511 thumbnailData = FuzzThumbnailData();
512 thumbnailData.originalPhotoPicture = FuzzPicture(false, false, true);
513 Media::SourceLoader sourceLoader5(desiredSize, thumbnailData);
514 sourceLoader5.CreateSourceWithOriginalPictureMainPixel();
515
516 thumbnailData = FuzzThumbnailData();
517 desiredSize = FuzzSize();
518 thumbnailData.path = TEST_IMAGE_PATH;
519 thumbnailData.mediaType = Media::MediaType::MEDIA_TYPE_IMAGE;
520 thumbnailData.loaderOpts.loadingStates = {
521 { Media::SourceState::BEGIN, Media::SourceState::LOCAL_ORIGIN },
522 { Media::SourceState::LOCAL_ORIGIN, Media::SourceState::FINISH },
523 };
524 Media::SourceLoader sourceLoader6(desiredSize, thumbnailData);
525 int32_t ret = sourceLoader6.RunLoading();
526 MEDIA_INFO_LOG("sourceLoader6.RunLoading image path: %{public}s. ret: %{public}d", TEST_IMAGE_PATH.c_str(), ret);
527 }
528
ParseFileUriTest()529 static void ParseFileUriTest()
530 {
531 string outFileId;
532 string outNetworkId;
533 string outTableName;
534 Media::Size outSize;
535 string outPath;
536 int32_t outType = 0;
537 int32_t outBeginStamp = 0;
538 string uri = FuzzThumbnailUri(true);
539 Media::ThumbnailUriUtils::ParseFileUri(uri, outFileId, outNetworkId, outTableName);
540 Media::ThumbnailUriUtils::ParseThumbnailInfo(uri, outFileId, outSize, outPath, outTableName);
541 Media::ThumbnailUriUtils::ParseKeyFrameThumbnailInfo(uri, outFileId, outBeginStamp, outType, outPath);
542 Media::ThumbnailUriUtils::GetDateTakenFromUri(uri);
543 Media::ThumbnailUriUtils::GetDateModifiedFromUri(uri);
544 Media::ThumbnailUriUtils::GetFileUriFromUri(uri);
545 Media::Size checkSize = FuzzSize();
546 Media::ThumbnailUriUtils::IsOriginalImg(checkSize, outPath);
547 Media::ThumbnailUriUtils::CheckSize(checkSize, outPath);
548 Media::ThumbnailUriUtils::GetTableFromUri(uri);
549 }
550
ThumbnailImageFrameworkUtilsTest()551 static void ThumbnailImageFrameworkUtilsTest()
552 {
553 std::shared_ptr<Media::PixelMap> pixelMap = FuzzNormalPixelMap(true);
554 std::shared_ptr<Media::Picture> picture = FuzzPicture(true, false, true);
555 Media::ThumbnailImageFrameWorkUtils::IsYuvPixelMap(pixelMap);
556 Media::ThumbnailImageFrameWorkUtils::IsSupportCopyPixelMap(pixelMap);
557 Media::ThumbnailImageFrameWorkUtils::CopyPictureSource(picture);
558 Media::ThumbnailImageFrameWorkUtils::CopyPixelMapSource(pixelMap);
559
560 pixelMap = FuzzYuvPixelMap(false);
561 picture = FuzzPicture(true, true, false);
562 Media::ThumbnailImageFrameWorkUtils::IsYuvPixelMap(pixelMap);
563 Media::ThumbnailImageFrameWorkUtils::IsSupportCopyPixelMap(pixelMap);
564 Media::ThumbnailImageFrameWorkUtils::CopyPictureSource(picture);
565 Media::ThumbnailImageFrameWorkUtils::CopyPixelMapSource(pixelMap);
566 }
567
ThumbnailFileUtilsTest()568 static void ThumbnailFileUtilsTest()
569 {
570 Media::ThumbnailData thumbnailData;
571 thumbnailData.path = FuzzThumbnailPath();
572 Media::ThumbnailFileUtils::DeleteThumbnailDir(thumbnailData);
573 thumbnailData.path = FuzzThumbnailPath();
574 Media::ThumbnailFileUtils::DeleteAllThumbFiles(thumbnailData);
575 Media::ThumbnailFileUtils::DeleteMonthAndYearAstc(thumbnailData);
576 Media::ThumbnailFileUtils::CheckRemainSpaceMeetCondition(provider->ConsumeIntegral<int32_t>());
577 Media::ThumbnailFileUtils::DeleteAstcDataFromKvStore(thumbnailData, FuzzThumbnailType());
578 }
579
AddSeed()580 static int32_t AddSeed()
581 {
582 char *seedData = new char[OHOS::SEED_SIZE];
583 for (int i = 0; i < OHOS::SEED_SIZE; i++) {
584 seedData[i] = static_cast<char>(i % MAX_BYTE_VALUE);
585 }
586
587 const char* filename = "corpus/seed.txt";
588 std::ofstream file(filename, std::ios::binary | std::ios::trunc);
589 if (!file) {
590 MEDIA_ERR_LOG("Cannot open file filename:%{public}s", filename);
591 delete[] seedData;
592 return Media::E_ERR;
593 }
594 file.write(seedData, OHOS::SEED_SIZE);
595 file.close();
596 delete[] seedData;
597 MEDIA_INFO_LOG("seedData has been successfully written to file filename:%{public}s", filename);
598 return Media::E_OK;
599 }
600 } // namespace OHOS
601
LLVMFuzzerInitialize(int * argc,char *** argv)602 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
603 {
604 OHOS::AddSeed();
605 OHOS::Init();
606 return 0;
607 }
608
609 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)610 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
611 {
612 FuzzedDataProvider fdp(data, size);
613 OHOS::provider = &fdp;
614 if (data == nullptr) {
615 return 0;
616 }
617 OHOS::ThumhnailTest();
618 OHOS::ThumbnailAgingHelperTest();
619 OHOS::ThumbnailGenerateHelperTest();
620 OHOS::ThumbnailGenerateWorkerTest();
621 OHOS::ThumbnailGenerateWorkerManagerTest();
622 OHOS::ThumbnailSourceTest();
623 OHOS::ThumbnailSourceTest2();
624 OHOS::ParseFileUriTest();
625 OHOS::ThumbnailImageFrameworkUtilsTest();
626 OHOS::ThumbnailFileUtilsTest();
627 OHOS::Finish();
628 return 0;
629 }