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