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
16 #include <cstddef>
17 #include <cstdint>
18 #include <memory>
19
20 #include "accesstoken_kit.h"
21 #include "camera_input.h"
22 #include "camera_log.h"
23 #include "camera_photo_proxy.h"
24 #include "capture_input.h"
25 #include "capture_output.h"
26 #include "capture_scene_const.h"
27 #include "capture_session_fuzzer.h"
28 #include "input/camera_manager.h"
29 #include "ipc_skeleton.h"
30 #include "iservice_registry.h"
31 #include "input/camera_manager_for_sys.h"
32 #include "message_parcel.h"
33 #include "nativetoken_kit.h"
34 #include "os_account_manager.h"
35 #include "preview_output.h"
36 #include "refbase.h"
37 #include "system_ability_definition.h"
38 #include "test_token.h"
39 #include "token_setproc.h"
40
41
42 namespace OHOS {
43 namespace CameraStandard {
44 namespace CaptureSessionFuzzer {
45 const int32_t LIMITSIZE = 309;
46 const int32_t NUM_TWO = 2;
47 const int32_t NUM_20 = 20;
48 const int32_t NUM_40 = 40;
49
50 sptr<IBufferProducer> surface;
51 sptr<CameraDevice> camera;
52 Profile profile;
53 CaptureOutput* curOutput;
54 bool g_isSupported;
55 bool g_isCameraDevicePermission = false;
56 SceneMode g_sceneMode;
57 std::vector<Profile> previewProfile_ = {};
58
59 sptr<CameraManager> manager_;
60
GetCameraInput(FuzzedDataProvider & fdp)61 sptr<CaptureInput> GetCameraInput(FuzzedDataProvider& fdp)
62 {
63 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
64 auto manager = CameraManager::GetInstance();
65 auto cameras = manager->GetSupportedCameras();
66 CHECK_RETURN_RET_ELOG(cameras.size() < NUM_TWO, nullptr, "CaptureSessionFuzzer: GetSupportedCameras Error");
67 camera = cameras[fdp.ConsumeIntegral<uint32_t>() % cameras.size()];
68 CHECK_RETURN_RET_ELOG(!camera, nullptr, "CaptureSessionFuzzer: Camera is null Error");
69 return manager->CreateCameraInput(camera);
70 }
71
CreatePreviewOutput(Profile previewProfile)72 sptr<CaptureOutput> CreatePreviewOutput(Profile previewProfile)
73 {
74 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
75 if (surface == nullptr) {
76 return nullptr;
77 }
78 return manager_->CreatePreviewOutput(previewProfile, surface);
79 }
80
Test(uint8_t * data,size_t size)81 void Test(uint8_t* data, size_t size)
82 {
83 CHECK_RETURN(size < LIMITSIZE);
84 CHECK_RETURN_ELOG(!TestToken().GetAllCameraPermission(), "GetPermission error");
85 manager_ = CameraManager::GetInstance();
86 sptr<CaptureSessionForSys> session =
87 CameraManagerForSys::GetInstance()->CreateCaptureSessionForSys(SceneMode::CAPTURE);
88 std::vector<sptr<CameraDevice>> cameras = manager_->GetCameraDeviceListFromServer();
89 CHECK_RETURN_ELOG(cameras.empty(), "GetCameraDeviceListFromServer Error");
90 sptr<CaptureInput> input = manager_->CreateCameraInput(cameras[0]);
91 CHECK_RETURN_ELOG(!input, "CreateCameraInput Error");
92 input->Open();
93 auto outputCapability = manager_->GetSupportedOutputCapability(cameras[0], 0);
94 CHECK_RETURN_ELOG(!outputCapability, "GetSupportedOutputCapability Error");
95 previewProfile_ = outputCapability->GetPreviewProfiles();
96 CHECK_RETURN_ELOG(previewProfile_.empty(), "GetPreviewProfiles Error");
97 outputCapability->GetVideoProfiles();
98 sptr<CaptureOutput> preview = CreatePreviewOutput(previewProfile_[0]);
99 session->BeginConfig();
100 session->AddInput(input);
101 session->AddOutput(preview);
102 session->CommitConfig();
103 sptr<ICameraDeviceService> deviceObj = nullptr;
104 manager_->CreateCameraDevice(cameras[0]->GetID(), &deviceObj);
105 sptr<CameraInput> camInput = (sptr<CameraInput>&)input;
106 camInput->SwitchCameraDevice(deviceObj, cameras[0]);
107 input->GetCameraDeviceInfo();
108 session->SetInputDevice(input);
109 session->GetInputDevice()->GetCameraDeviceInfo();
110 preview->outputType_ = CAPTURE_OUTPUT_TYPE_DEPTH_DATA;
111 session->CanAddOutput(preview);
112 FuzzedDataProvider fdp(data, size);
113 TestCallback(session, fdp);
114 TestExposure(session, fdp);
115 TestFocus(session, fdp);
116 TestZoom(session, fdp);
117 TestStabilization(session, fdp);
118 TestProcess(session, fdp);
119 TestAperture(session, fdp);
120 TestBeauty(session, fdp);
121 TestOther(session, fdp);
122 TestOther3(session, fdp);
123 TestFlash(session, fdp);
124 TestAdd(session, fdp);
125 TestSession(session, fdp);
126 TestOther2(session, fdp);
127 session->Release();
128 session->Stop();
129 }
130
GetCaptureOutput(FuzzedDataProvider & fdp)131 sptr<PhotoOutput> GetCaptureOutput(FuzzedDataProvider& fdp)
132 {
133 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
134 auto manager = CameraManager::GetInstance();
135 CHECK_RETURN_RET_ELOG(!manager, nullptr, "CaptureSessionFuzzer: CameraManager::GetInstance Error");
136 CHECK_RETURN_RET_ELOG(!camera, nullptr, "CaptureSessionFuzzer: Camera is null Error");
137 auto capability = manager->GetSupportedOutputCapability(camera, g_sceneMode);
138 CHECK_RETURN_RET_ELOG(!capability, nullptr, "CaptureSessionFuzzer: GetSupportedOutputCapability Error");
139 auto profiles = capability->GetPhotoProfiles();
140 CHECK_RETURN_RET_ELOG(profiles.empty(), nullptr, "CaptureSessionFuzzer: GetPhotoProfiles empty");
141 profile = profiles[fdp.ConsumeIntegral<uint32_t>() % profiles.size()];
142 sptr<IConsumerSurface> photoSurface = IConsumerSurface::Create();
143 CHECK_RETURN_RET_ELOG(!photoSurface, nullptr, "CaptureSessionFuzzer: create photoSurface Error");
144 surface = photoSurface->GetProducer();
145 CHECK_RETURN_RET_ELOG(!surface, nullptr, "CaptureSessionFuzzer: surface GetProducer Error");
146 return manager->CreatePhotoOutput(profile, surface);
147 }
148
TestExposure(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)149 void TestExposure(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
150 {
151 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
152 session->GetSupportedExposureModes();
153 vector<ExposureMode> exposureModes;
154 session->GetSupportedExposureModes(exposureModes);
155 ExposureMode exposureMode = static_cast<ExposureMode>(
156 fdp.ConsumeIntegral<int32_t>() % (ExposureMode::EXPOSURE_MODE_CONTINUOUS_AUTO + NUM_TWO));
157 session->IsExposureModeSupported(exposureMode);
158 session->IsExposureModeSupported(exposureMode, g_isSupported);
159 session->GetExposureMode();
160 session->GetExposureMode(exposureMode);
161 session->GetMeteringPoint();
162 Point exposurePoint;
163 session->GetMeteringPoint(exposurePoint);
164 session->GetExposureBiasRange();
165 vector<float> exposureBiasRange;
166 session->GetExposureBiasRange(exposureBiasRange);
167 session->GetExposureValue();
168 float exposure;
169 session->GetExposureValue(exposure);
170 session->LockForControl();
171 session->SetExposureMode(exposureMode);
172 session->SetMeteringPoint(exposurePoint);
173 float exposureBias = fdp.ConsumeFloatingPoint<double>();
174 session->SetExposureBias(exposureBias);
175 vector<uint32_t> sensorExposureTimeRange;
176 session->GetSensorExposureTimeRange(sensorExposureTimeRange);
177 session->SetSensorExposureTime(fdp.ConsumeIntegral<uint32_t>());
178 uint32_t sensorExposureTime;
179 session->GetSensorExposureTime(sensorExposureTime);
180 session->UnlockForControl();
181 }
182
TestFocus(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)183 void TestFocus(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
184 {
185 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
186 session->GetSupportedFocusModes();
187 vector<FocusMode> focusModes;
188 session->GetSupportedFocusModes(focusModes);
189 FocusMode focusMode = static_cast<FocusMode>(
190 fdp.ConsumeIntegral<int32_t>() % (FocusMode::FOCUS_MODE_LOCKED + NUM_TWO));
191 session->IsFocusModeSupported(focusMode);
192 session->IsFocusModeSupported(focusMode, g_isSupported);
193 session->GetFocusMode();
194 session->GetFocusMode(focusMode);
195 session->GetFocusPoint();
196 Point focusPoint;
197 session->GetFocusPoint(focusPoint);
198 session->GetFocalLength();
199 float focalLength;
200 session->GetFocalLength(focalLength);
201 float distance;
202 session->GetFocusDistance(distance);
203 session->GetMinimumFocusDistance();
204 session->LockForControl();
205 session->SetFocusMode(focusMode);
206 session->SetFocusPoint(focusPoint);
207 session->UnlockForControl();
208 }
209
TestZoom(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)210 void TestZoom(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
211 {
212 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
213 session->GetZoomRatioRange();
214 vector<float> zoomRatioRange;
215 session->GetZoomRatioRange(zoomRatioRange);
216 session->GetZoomRatio();
217 float zoomRatio;
218 session->GetZoomRatio(zoomRatio);
219 vector<ZoomPointInfo> zoomPointInfoList;
220 session->GetZoomPointInfos(zoomPointInfoList);
221 session->LockForControl();
222 session->SetZoomRatio(zoomRatio);
223 session->PrepareZoom();
224 session->UnPrepareZoom();
225 float targetZoomRatio = fdp.ConsumeFloatingPoint<double>();
226 uint32_t smoothZoomType = fdp.ConsumeIntegral<uint32_t>();
227 session->SetSmoothZoom(targetZoomRatio, smoothZoomType);
228 session->UnlockForControl();
229 }
230
TestCallback(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)231 void TestCallback(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
232 {
233 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
234 session->SetCallback(make_shared<SessionCallbackMock>());
235 session->SetExposureCallback(make_shared<ExposureCallbackMock>());
236 session->SetFocusCallback(make_shared<FocusCallbackMock>());
237 session->SetSmoothZoomCallback(make_shared<SmoothZoomCallbackMock>());
238 session->SetMacroStatusCallback(make_shared<MacroStatusCallbackMock>());
239 session->SetMoonCaptureBoostStatusCallback(make_shared<MoonCaptureBoostStatusCallbackMock>());
240 auto fdsCallback = make_shared<FeatureDetectionStatusCallbackMock>(fdp.ConsumeBool());
241 session->SetFeatureDetectionStatusCallback(fdsCallback);
242 session->SetEffectSuggestionCallback(make_shared<EffectSuggestionCallbackMock>());
243 session->SetARCallback(make_shared<ARCallbackMock>());
244 session->SetAbilityCallback(make_shared<AbilityCallbackMock>());
245 session->GetApplicationCallback();
246 session->GetExposureCallback();
247 session->GetFocusCallback();
248 session->GetMacroStatusCallback();
249 session->GetMoonCaptureBoostStatusCallback();
250 session->GetFeatureDetectionStatusCallback();
251 session->GetSmoothZoomCallback();
252 session->GetARCallback();
253 }
254
TestStabilization(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)255 void TestStabilization(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
256 {
257 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
258 session->GetSupportedStabilizationMode();
259 vector<VideoStabilizationMode> modes;
260 session->GetSupportedStabilizationMode(modes);
261 VideoStabilizationMode stabilizationMode = static_cast<VideoStabilizationMode>(
262 fdp.ConsumeIntegral<int32_t>() % (VideoStabilizationMode::AUTO + NUM_TWO));
263 session->IsVideoStabilizationModeSupported(stabilizationMode);
264 session->IsVideoStabilizationModeSupported(stabilizationMode, g_isSupported);
265 VideoStabilizationMode mode;
266 session->GetActiveVideoStabilizationMode();
267 session->GetActiveVideoStabilizationMode(mode);
268 session->SetVideoStabilizationMode(stabilizationMode);
269 }
270
TestFlash(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)271 void TestFlash(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
272 {
273 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
274 session->GetSupportedFlashModes();
275 vector<FlashMode> flashModes;
276 session->GetSupportedFlashModes(flashModes);
277 session->HasFlash();
278 bool hasFlash;
279 session->HasFlash(hasFlash);
280 FlashMode flashMode = static_cast<FlashMode>(
281 fdp.ConsumeIntegral<int32_t>() % (FlashMode::FLASH_MODE_ALWAYS_OPEN + NUM_TWO));
282 session->IsFlashModeSupported(flashMode);
283 session->IsFlashModeSupported(flashMode, g_isSupported);
284 session->GetFlashMode();
285 session->GetFlashMode(flashMode);
286 session->SetFlashMode(flashMode);
287 }
288
TestProcess(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)289 void TestProcess(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
290 {
291 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
292 static const size_t ITEM_CAP = 10;
293 static const size_t DATA_CAP = 100;
294 shared_ptr<OHOS::Camera::CameraMetadata> result = make_shared<OHOS::Camera::CameraMetadata>(ITEM_CAP, DATA_CAP);
295 int32_t idata = fdp.ConsumeIntegral<int32_t>();
296 result->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &idata, 1);
297 result->addEntry(OHOS_CONTROL_FOCUS_MODE, &idata, 1);
298 camera_rational_t cr = {fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()};
299 result->addEntry(OHOS_STATUS_SENSOR_EXPOSURE_TIME, &cr, 1);
300 result->addEntry(CAMERA_POSITION_FRONT, &idata, 1);
301 result->addEntry(OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &idata, 1);
302 result->addEntry(OHOS_CAMERA_MACRO_STATUS, &idata, 1);
303 result->addEntry(OHOS_STATUS_MOON_CAPTURE_DETECTION, &idata, 1);
304 result->addEntry(OHOS_CAMERA_EFFECT_SUGGESTION_TYPE, &idata, 1);
305 session->ProcessAutoExposureUpdates(result);
306 session->ProcessAutoFocusUpdates(result);
307 session->ProcessAREngineUpdates(fdp.ConsumeIntegral<uint64_t>(), result);
308 session->ProcessSnapshotDurationUpdates(fdp.ConsumeIntegral<uint64_t>(), result);
309 session->ProcessMacroStatusChange(result);
310 session->ProcessMoonCaptureBoostStatusChange(result);
311 session->ProcessEffectSuggestionTypeUpdates(result);
312 }
313
TestAperture(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)314 void TestAperture(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
315 {
316 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
317 uint32_t moduleType;
318 session->GetModuleType(moduleType);
319 session->IsEffectSuggestionSupported();
320 session->GetSupportedEffectSuggestionInfo();
321 session->GetSupportedEffectSuggestionType();
322
323 session->LockForControl();
324 session->SetARMode(fdp.ConsumeBool());
325 session->EnableEffectSuggestion(fdp.ConsumeBool());
326 vector<EffectSuggestionStatus> effectSuggestionStatusList;
327 size_t max = EffectSuggestionType::EFFECT_SUGGESTION_SUNRISE_SUNSET + NUM_TWO;
328 for (size_t i = 0; i < fdp.ConsumeIntegral<int32_t>() % max; i++) {
329 EffectSuggestionStatus status = {
330 static_cast<EffectSuggestionType>(fdp.ConsumeIntegral<int32_t>() % max),
331 fdp.ConsumeBool(),
332 };
333 effectSuggestionStatusList.push_back(status);
334 }
335 session->SetEffectSuggestionStatus(effectSuggestionStatusList);
336 EffectSuggestionType effectSuggestionType = static_cast<EffectSuggestionType>(fdp.ConsumeIntegral<int32_t>() % max);
337 session->UpdateEffectSuggestion(effectSuggestionType, fdp.ConsumeBool());
338 session->UnlockForControl();
339 }
340
TestBeauty(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)341 void TestBeauty(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
342 {
343 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
344 session->GetSupportedFilters();
345 session->GetSupportedBeautyTypes();
346 BeautyType type = static_cast<BeautyType>(
347 fdp.ConsumeIntegral<int32_t>() % (BeautyType::SKIN_TONE + NUM_TWO));
348 session->GetSupportedBeautyRange(type);
349 session->GetBeauty(type);
350 session->GetSupportedColorSpaces();
351 ColorSpace colorSpace;
352 session->GetActiveColorSpace(colorSpace);
353 session->GetSupportedColorEffects();
354 session->GetColorEffect();
355 session->GetFilter();
356 FilterType filter = static_cast<FilterType>(
357 fdp.ConsumeIntegral<int32_t>() % (FilterType::PINK + NUM_TWO));
358 session->LockForControl();
359 session->SetFilter(filter);
360 session->SetColorSpace(colorSpace);
361 ColorEffect colorEffect = static_cast<ColorEffect>(
362 fdp.ConsumeIntegral<int32_t>() % (ColorEffect::COLOR_EFFECT_BLACK_WHITE + NUM_TWO));
363 session->SetColorEffect(colorEffect);
364 BeautyType beautyType = static_cast<BeautyType>(
365 fdp.ConsumeIntegral<int32_t>() % (BeautyType::SKIN_TONE + NUM_TWO));
366 session->SetBeautyValue(beautyType, fdp.ConsumeIntegral<int32_t>());
367 session->SetBeauty(type, fdp.ConsumeIntegral<int32_t>());
368 session->UnlockForControl();
369 }
370
TestOther(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)371 void TestOther(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
372 {
373 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
374 session->IsMacroSupported();
375 session->IsMovingPhotoSupported();
376 session->IsMoonCaptureBoostSupported();
377 SceneFeature feature = static_cast<SceneFeature>(
378 fdp.ConsumeIntegral<int32_t>() % (SceneFeature::FEATURE_ENUM_MAX + NUM_TWO));
379 session->IsFeatureSupported(feature);
380 vector<int32_t> sensitivityRange;
381 session->GetSensorSensitivityRange(sensitivityRange);
382 session->GetFeaturesMode();
383 session->GetSubFeatureMods();
384 session->IsSetEnableMacro();
385 session->GetMetaOutput();
386 session->GetMetadata();
387 session->IsMovingPhotoEnabled();
388 session->IsImageDeferred();
389 session->CanSetFrameRateRange(fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>(), curOutput);
390 session->CanSetFrameRateRangeForOutput(fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>(), curOutput);
391 session->ExecuteAbilityChangeCallback();
392 session->EnableFeature(feature, fdp.ConsumeBool());
393 vector<int32_t> frameRateRange{fdp.ConsumeIntegral<int32_t>(), fdp.ConsumeIntegral<int32_t>()};
394 session->SetFrameRateRange(frameRateRange);
395 DeferredDeliveryImageType deferredType = static_cast<DeferredDeliveryImageType>(
396 fdp.ConsumeIntegral<int32_t>() % (DeferredDeliveryImageType::DELIVERY_VIDEO + NUM_TWO));
397 session->EnableDeferredType(deferredType, fdp.ConsumeBool());
398 session->SetUserId();
399 session->EnableAutoHighQualityPhoto(fdp.ConsumeBool());
400 session->EnableRawDelivery(fdp.ConsumeBool());
401 auto curMinFps = fdp.ConsumeIntegral<int32_t>();
402 auto curMaxFps = fdp.ConsumeIntegral<int32_t>();
403 auto minFps = fdp.ConsumeIntegral<int32_t>();
404 auto maxFps = fdp.ConsumeIntegral<int32_t>();
405 session->CheckFrameRateRangeWithCurrentFps(curMinFps, curMaxFps, minFps, maxFps);
406 session->CheckFrameRateRangeWithCurrentFps(NUM_20, NUM_20, NUM_40, NUM_40);
407 session->CheckFrameRateRangeWithCurrentFps(NUM_40, NUM_40, NUM_20, NUM_20);
408 ProfileSizeRatio sizeRatio = RATIO_1_1;
409 session->GetMaxSizePhotoProfile(sizeRatio);
410 session->GetPreconfigPreviewProfile();
411 session->GetPreconfigPhotoProfile();
412 session->GetPreconfigVideoProfile();
413 session->IsVideoDeferred();
414 }
415
TestOther2(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)416 void TestOther2(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
417 {
418 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
419 camera_face_detect_mode_t t = static_cast<camera_face_detect_mode_t>(
420 fdp.ConsumeIntegral<int32_t>() % (camera_face_detect_mode_t::OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE + NUM_TWO));
421 set<camera_face_detect_mode_t> metadataObjectTypes;
422 metadataObjectTypes.insert(t);
423 session->SetCaptureMetadataObjectTypes(metadataObjectTypes);
424 uint32_t ability = fdp.ConsumeIntegral<uint32_t>();
425 session->VerifyAbility(ability);
426 session->SetFocusDistance(fdp.ConsumeFloatingPoint<double>());
427 session->EnableMacro(fdp.ConsumeBool());
428 session->EnableMovingPhoto(fdp.ConsumeBool());
429 session->EnableMovingPhotoMirror(fdp.ConsumeBool(), fdp.ConsumeBool());
430 session->EnableMoonCaptureBoost(fdp.ConsumeBool());
431 session->SetSensorSensitivity(fdp.ConsumeIntegral<uint32_t>());
432 int32_t wbValue = fdp.ConsumeIntegral<int32_t>();
433 session->GetManualWhiteBalance(wbValue);
434 std::vector<std::vector<float>> supportedPhysicalApertures = {};
435 session->GetSupportedPhysicalApertures(supportedPhysicalApertures);
436 std::vector<float> apertures;
437 session->GetSupportedVirtualApertures(apertures);
438 float aperture = fdp.ConsumeFloatingPoint<double>();
439 session->GetVirtualAperture(aperture);
440 session->SetVirtualAperture(aperture);
441 session->GetPhysicalAperture(aperture);
442 session->SetPhysicalAperture(aperture);
443 session->UnlockForControl();
444 }
445
TestSession(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)446 void TestSession(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
447 {
448 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
449 sptr<CaptureInput> input = GetCameraInput(fdp);
450 sptr<CaptureOutput> output = GetCaptureOutput(fdp);
451 CHECK_RETURN_ELOG(!input || !output || !session, "CaptureSessionFuzzer: input/output/session is null");
452 session->SetMode(g_sceneMode);
453 session->GetMode();
454 PreconfigType preconfigType = static_cast<PreconfigType>(
455 fdp.ConsumeIntegral<int32_t>() % (PreconfigType::PRECONFIG_HIGH_QUALITY + NUM_TWO));
456 ProfileSizeRatio preconfigRatio = static_cast<ProfileSizeRatio>(
457 fdp.ConsumeIntegral<int32_t>() % (ProfileSizeRatio::RATIO_16_9 + NUM_TWO));
458 session->CanPreconfig(preconfigType, preconfigRatio);
459 session->Preconfig(preconfigType, preconfigRatio);
460 session->BeginConfig();
461 session->CanAddInput(input);
462 session->AddInput(input);
463 session->CanAddOutput(output);
464 session->AddOutput(output);
465 session->RemoveInput(input);
466 session->RemoveOutput(output);
467 session->AddInput(input);
468 session->AddOutput(output);
469 session->AddSecureOutput(output);
470 input->Open();
471 session->CommitConfig();
472 session->CheckSpecSearch();
473 session->Start();
474 curOutput = output.GetRefPtr();
475 CaptureOutputType outputType = static_cast<CaptureOutputType>(
476 fdp.ConsumeIntegral<int32_t>() % (CaptureOutputType::CAPTURE_OUTPUT_TYPE_MAX + NUM_TWO));
477 session->ValidateOutputProfile(profile, outputType);
478 session->GeneratePreconfigProfiles(preconfigType, preconfigRatio);
479 session->EnableAutoDeferredVideoEnhancement(fdp.ConsumeBool());
480 session->ConfigurePhotoOutput(output);
481 }
482
TestAdd(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)483 void TestAdd(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
484 {
485 std::vector<PortraitThemeType> supportedPortraitThemeTypes = {
486 PortraitThemeType::NATURAL,
487 PortraitThemeType::DELICATE,
488 PortraitThemeType::STYLISH
489 };
490 session->SetPortraitThemeType(PortraitThemeType::NATURAL);
491 session->GetSupportedPortraitThemeTypes(supportedPortraitThemeTypes);
492 session->IsPortraitThemeSupported();
493 std::vector<int32_t> supportedRotation = {0, 90, 180, 270};
494 session->GetSupportedVideoRotations(supportedRotation);
495 std::vector<float> depthFusionThreshold = {0.0};
496 session->GetDepthFusionThreshold(depthFusionThreshold);
497 session->EnableDepthFusion(fdp.ConsumeBool());
498 session->IsDepthFusionEnabled();
499 session->IsVideoRotationSupported();
500 session->SetVideoRotation(fdp.ConsumeIntegral<int32_t>());
501 session->SetIsAutoSwitchDeviceStatus(fdp.ConsumeBool());
502 FoldCallback *fold = new FoldCallback(session);
503 fold->OnFoldStatusChanged(FoldStatus::UNKNOWN_FOLD);
504 session->ExecuteAllFunctionsInMap();
505 session->CreateAndSetFoldServiceCallback();
506 shared_ptr<AutoDeviceSwitchCallback> autoDeviceSwitchCallback = nullptr;
507 session->SwitchDevice();
508 session->FindFrontCamera();
509 session->SetAutoDeviceSwitchCallback(autoDeviceSwitchCallback);
510 session->GetAutoDeviceSwitchCallback();
511 session->StartVideoOutput();
512 session->StopVideoOutput();
513 session->SetUsage(UsageType::BOKEH, fdp.ConsumeBool());
514 session->IsAutoDeviceSwitchSupported();
515 session->EnableAutoDeviceSwitch(fdp.ConsumeBool());
516 session->CreateCameraAbilityContainer();
517 }
518
TestOther3(sptr<CaptureSessionForSys> session,FuzzedDataProvider & fdp)519 void TestOther3(sptr<CaptureSessionForSys> session, FuzzedDataProvider& fdp)
520 {
521 MEDIA_INFO_LOG("CaptureSessionFuzzer: ENTER");
522 QualityPrioritization qualityPrioritization = static_cast<QualityPrioritization>(
523 fdp.ConsumeIntegral<int32_t>() % (QualityPrioritization::HIGH_QUALITY + NUM_TWO));
524 session->LockForControl();
525 session->SetQualityPrioritization(qualityPrioritization);
526 session->EnableAutoAigcPhoto(fdp.ConsumeBool());
527 session->ProcessProfilesAbilityId(g_sceneMode);
528 Point point;
529 session->CoordinateTransform(point);
530 session->VerifyFocusCorrectness(point);
531 vector<FocusRangeType> types;
532 session->GetSupportedFocusRangeTypes(types);
533 FocusRangeType focusRangeType = static_cast<FocusRangeType>(
534 fdp.ConsumeIntegral<int32_t>() % (FocusRangeType::FOCUS_RANGE_TYPE_AUTO + NUM_TWO));
535 bool isSupported = fdp.ConsumeBool();
536 session->IsFocusRangeTypeSupported(focusRangeType, isSupported);
537 session->GetFocusRange(focusRangeType);
538 session->SetFocusRange(focusRangeType);
539 vector<FocusDrivenType> types1;
540 session->GetSupportedFocusDrivenTypes(types1);
541 FocusDrivenType focusDrivenType = static_cast<FocusDrivenType>(
542 fdp.ConsumeIntegral<int32_t>() % (FocusDrivenType::FOCUS_DRIVEN_TYPE_AUTO + NUM_TWO));
543 session->IsFocusDrivenTypeSupported(focusDrivenType, isSupported);
544 session->GetFocusDriven(focusDrivenType);
545 session->SetFocusDriven(focusDrivenType);
546 vector<ColorReservationType> types2;
547 session->GetSupportedColorReservationTypes(types2);
548 ColorReservationType colorReservationType = static_cast<ColorReservationType>(
549 fdp.ConsumeIntegral<int32_t>() % (ColorReservationType::COLOR_RESERVATION_TYPE_NONE + NUM_TWO));
550 session->IsColorReservationTypeSupported(colorReservationType, isSupported);
551 session->GetColorReservation(colorReservationType);
552 session->SetColorReservation(colorReservationType);
553 WhiteBalanceMode mode = AWB_MODE_LOCKED;
554 session->SetWhiteBalanceMode(mode);
555 std::vector<WhiteBalanceMode> supportedWhiteBalanceModes = {};
556 session->GetSupportedWhiteBalanceModes(supportedWhiteBalanceModes);
557 session->IsWhiteBalanceModeSupported(mode, isSupported);
558 session->GetWhiteBalanceMode(mode);
559 std::vector<int32_t> whiteBalanceRange = {};
560 session->GetManualWhiteBalanceRange(whiteBalanceRange);
561 session->IsManualWhiteBalanceSupported(isSupported);
562 session->SetManualWhiteBalance(fdp.ConsumeIntegral<int32_t>());
563 session->SetWhiteBalanceMode(WhiteBalanceMode::AWB_MODE_AUTO);
564 session->UnlockForControl();
565 }
566
567 } // namespace StreamRepeatStubFuzzer
568 } // namespace CameraStandard
569 } // namespace OHOS
570
571 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(uint8_t * data,size_t size)572 extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size)
573 {
574 /* Run your code on data */
575 OHOS::CameraStandard::CaptureSessionFuzzer::Test(data, size);
576 return 0;
577 }