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 "time_lapse_photo_session_fuzzer.h"
17 #include "camera_log.h"
18 #include "camera_output_capability.h"
19 #include "input/camera_manager.h"
20 #include "message_parcel.h"
21 #include "time_lapse_photo_session.h"
22 #include "token_setproc.h"
23 #include "nativetoken_kit.h"
24 #include "accesstoken_kit.h"
25 
26 namespace OHOS {
27 namespace CameraStandard {
28 namespace TimeLapsePhotoSessionFuzzer {
29 const int32_t LIMITSIZE = 4;
30 const int32_t NUM_2 = 2;
GetPermission()31 void GetPermission()
32 {
33     uint64_t tokenId;
34     const char* perms[2];
35     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
36     perms[1] = "ohos.permission.CAMERA";
37     NativeTokenInfoParams infoInstance = {
38         .dcapsNum = 0,
39         .permsNum = 2,
40         .aclsNum = 0,
41         .dcaps = NULL,
42         .perms = perms,
43         .acls = NULL,
44         .processName = "native_camera_tdd",
45         .aplStr = "system_basic",
46     };
47     tokenId = GetAccessTokenId(&infoInstance);
48     SetSelfTokenID(tokenId);
49     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
50 }
51 
52 sptr<CameraManager> manager;
53 sptr<TimeLapsePhotoSession> session;
54 sptr<CameraDevice> camera;
55 SceneMode sceneMode = SceneMode::TIMELAPSE_PHOTO;
56 
AddOutput()57 auto AddOutput()
58 {
59     sptr<CameraOutputCapability> capability = manager->GetSupportedOutputCapability(camera, sceneMode);
60     CHECK_AND_RETURN_LOG(capability, "TimeLapsePhotoSessionFuzzer: capability Error");
61     Profile preview(CameraFormat::CAMERA_FORMAT_YUV_420_SP, {640, 480});
62     sptr<CaptureOutput> previewOutput = manager->CreatePreviewOutput(preview, Surface::CreateSurfaceAsConsumer());
63     CHECK_AND_RETURN_LOG(previewOutput, "TimeLapsePhotoSessionFuzzer: previewOutput Error");
64     session->AddOutput(previewOutput);
65     Profile photo(CameraFormat::CAMERA_FORMAT_JPEG, {640, 480});
66     sptr<IConsumerSurface> photoSurface = IConsumerSurface::Create();
67     CHECK_AND_RETURN_LOG(photoSurface, "TimeLapsePhotoSessionFuzzer: photoSurface Error");
68     sptr<IBufferProducer> surface = photoSurface->GetProducer();
69     CHECK_AND_RETURN_LOG(surface, "TimeLapsePhotoSessionFuzzer: surface Error");
70     sptr<CaptureOutput> photoOutput = manager->CreatePhotoOutput(photo, surface);
71     CHECK_AND_RETURN_LOG(photoOutput, "TimeLapsePhotoSessionFuzzer: photoOutput Error");
72     session->AddOutput(photoOutput);
73 }
74 
TestProcessor(uint8_t * rawData,size_t size)75 auto TestProcessor(uint8_t *rawData, size_t size)
76 {
77     class ExposureInfoCallbackMock : public ExposureInfoCallback {
78     public:
79         void OnExposureInfoChanged(ExposureInfo info) override {}
80     };
81     session->SetExposureInfoCallback(make_shared<ExposureInfoCallbackMock>());
82     camera_rational_t r = {1, 1000000};
83     auto meta = make_shared<OHOS::Camera::CameraMetadata>(10, 100);
84     meta->addEntry(OHOS_STATUS_SENSOR_EXPOSURE_TIME, &r, 1);
85     session->ProcessExposureChange(meta);
86     r.numerator++;
87     meta->updateEntry(OHOS_STATUS_SENSOR_EXPOSURE_TIME, &r, 1);
88     class IsoInfoCallbackMock : public IsoInfoCallback {
89     public:
90         void OnIsoInfoChanged(IsoInfo info) override {}
91     };
92     session->SetIsoInfoCallback(make_shared<IsoInfoCallbackMock>());
93     uint32_t iso = 1;
94     meta->addEntry(OHOS_STATUS_ISO_VALUE, &iso, 1);
95     session->ProcessIsoInfoChange(meta);
96     iso++;
97     meta->updateEntry(OHOS_STATUS_ISO_VALUE, &iso, 1);
98     static const uint32_t lumination = 256;
99     class LuminationInfoCallbackMock : public LuminationInfoCallback {
100     public:
101         void OnLuminationInfoChanged(LuminationInfo info) override {}
102     };
103     session->SetLuminationInfoCallback(make_shared<LuminationInfoCallbackMock>());
104     meta->addEntry(OHOS_STATUS_ALGO_MEAN_Y, &lumination, 1);
105 
106     static const int32_t value = 1;
107     class TryAEInfoCallbackMock : public TryAEInfoCallback {
108     public:
109         void OnTryAEInfoChanged(TryAEInfo info) override {}
110     };
111     session->SetTryAEInfoCallback(make_shared<TryAEInfoCallbackMock>());
112     meta->addEntry(OHOS_STATUS_TIME_LAPSE_TRYAE_DONE, &value, 1);
113     meta->addEntry(OHOS_STATUS_TIME_LAPSE_TRYAE_HINT, &value, 1);
114     meta->addEntry(OHOS_STATUS_TIME_LAPSE_PREVIEW_TYPE, &value, 1);
115     meta->addEntry(OHOS_STATUS_TIME_LAPSE_CAPTURE_INTERVAL, &value, 1);
116 
117     meta->addEntry(OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &value, 1);
118 
119     MessageParcel data;
120     data.WriteRawData(rawData, size);
121     TimeLapsePhotoSessionMetadataResultProcessor processor(session);
122     processor.ProcessCallbacks(data.ReadUint64(), meta);
123 }
124 
TestTimeLapsePhoto()125 auto TestTimeLapsePhoto()
126 {
127     bool isTryAENeeded;
128     session->IsTryAENeeded(isTryAENeeded);
129     session->LockForControl();
130     session->StartTryAE();
131     session->UnlockForControl();
132     session->LockForControl();
133     session->StopTryAE();
134     session->UnlockForControl();
135 
136     vector<int32_t> intervalRange;
137     session->GetSupportedTimeLapseIntervalRange(intervalRange);
138     if (!intervalRange.empty()) {
139         int32_t interval = intervalRange[intervalRange.size() - 1];
140         session->LockForControl();
141         session->SetTimeLapseInterval(interval);
142         session->UnlockForControl();
143         auto meta = session->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
144         AddOrUpdateMetadata(meta, OHOS_CONTROL_TIME_LAPSE_INTERVAL, &interval, 1);
145         session->GetTimeLapseInterval(interval);
146     }
147     session->LockForControl();
148     session->SetTimeLapseRecordState(TimeLapseRecordState::RECORDING);
149     session->UnlockForControl();
150     session->LockForControl();
151     session->SetTimeLapsePreviewType(TimeLapsePreviewType::DARK);
152     session->UnlockForControl();
153     session->LockForControl();
154     session->SetExposureHintMode(ExposureHintMode::EXPOSURE_HINT_MODE_OFF);
155     session->SetExposureHintMode(static_cast<ExposureHintMode>(ExposureHintMode::EXPOSURE_HINT_UNSUPPORTED + 1));
156     session->UnlockForControl();
157 }
158 
TestManualExposure(uint8_t * rawData,size_t size)159 auto TestManualExposure(uint8_t *rawData, size_t size)
160 {
161     MessageParcel data;
162     data.WriteRawData(rawData, size);
163     auto meta = session->GetMetadata();
164     const camera_rational_t rs[] = {
165         {3, 1000000},
166         {9, 1000000},
167     };
168     uint32_t dataCount = sizeof(rs) / sizeof(rs[0]);
169     AddOrUpdateMetadata(meta, OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, rs, dataCount);
170     vector<uint32_t> exposureRange;
171     session->GetSupportedExposureRange(exposureRange);
172     meta = session->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
173     session->LockForControl();
174     session->SetExposure(0);
175     session->SetExposure(1);
176     session->SetExposure(data.ReadUint32());
177     session->UnlockForControl();
178     uint32_t exposure = data.ReadUint32();
179     AddOrUpdateMetadata(meta, OHOS_CONTROL_SENSOR_EXPOSURE_TIME, &exposure, 1);
180     session->GetExposure(exposure);
181     vector<MeteringMode> modes;
182     session->GetSupportedMeteringModes(modes);
183     bool supported;
184     session->IsExposureMeteringModeSupported(METERING_MODE_CENTER_WEIGHTED, supported);
185     session->IsExposureMeteringModeSupported(
186         static_cast<MeteringMode>(MeteringMode::METERING_MODE_OVERALL + 1), supported);
187     session->LockForControl();
188     session->SetExposureMeteringMode(MeteringMode::METERING_MODE_CENTER_WEIGHTED);
189     session->SetExposureMeteringMode(static_cast<MeteringMode>(MeteringMode::METERING_MODE_OVERALL + 1));
190     session->UnlockForControl();
191     MeteringMode mode = MeteringMode::METERING_MODE_OVERALL;
192     AddOrUpdateMetadata(meta, OHOS_CONTROL_METER_MODE, &mode, 1);
193     session->GetExposureMeteringMode(mode);
194     mode = static_cast<MeteringMode>(MeteringMode::METERING_MODE_OVERALL + 1);
195     AddOrUpdateMetadata(meta, OHOS_CONTROL_METER_MODE, &mode, 1);
196     session->GetExposureMeteringMode(mode);
197 }
198 
TestManualIso()199 void TestManualIso()
200 {
201     auto meta = session->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
202     bool isManualIsoSupported;
203     session->IsManualIsoSupported(isManualIsoSupported);
204     if (isManualIsoSupported) {
205         vector<int32_t> isoRange;
206         session->GetIsoRange(isoRange);
207         if (!isoRange.empty()) {
208             session->LockForControl();
209             session->SetIso(isoRange[0]);
210             session->UnlockForControl();
211             int32_t iso = 1000;
212             AddOrUpdateMetadata(meta, OHOS_CONTROL_ISO_VALUE, &iso, 1);
213             session->GetIso(iso);
214         }
215     }
216     AddOrUpdateMetadata(meta, OHOS_ABILITY_ISO_VALUES, &isManualIsoSupported, 1);
217     session->IsManualIsoSupported(isManualIsoSupported);
218 }
219 
TestWhiteBalance()220 void TestWhiteBalance()
221 {
222     vector<WhiteBalanceMode> wbModes;
223     session->GetSupportedWhiteBalanceModes(wbModes);
224     bool isWhiteBalanceModeSupported;
225     session->IsWhiteBalanceModeSupported(WhiteBalanceMode::AWB_MODE_AUTO, isWhiteBalanceModeSupported);
226     session->LockForControl();
227     session->SetWhiteBalanceMode(WhiteBalanceMode::AWB_MODE_AUTO);
228     session->UnlockForControl();
229     WhiteBalanceMode wbMode;
230     session->GetWhiteBalanceMode(wbMode);
231     vector<int32_t> wbRange;
232     session->GetWhiteBalanceRange(wbRange);
233     if (!wbRange.empty()) {
234         session->LockForControl();
235         session->SetWhiteBalance(wbRange[0]);
236         session->UnlockForControl();
237         int32_t wb;
238         session->GetWhiteBalance(wb);
239     }
240     auto meta = session->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
241     camera_awb_mode_t awbModes[] = {camera_awb_mode_t::OHOS_CAMERA_AWB_MODE_AUTO};
242     AddOrUpdateMetadata(meta, OHOS_ABILITY_AWB_MODES, awbModes, 1);
243     session->GetSupportedWhiteBalanceModes(wbModes);
244     AddOrUpdateMetadata(meta, OHOS_CONTROL_AWB_MODE, awbModes, 1);
245     session->GetWhiteBalanceMode(wbMode);
246     session->LockForControl();
247     session->SetWhiteBalanceMode(static_cast<WhiteBalanceMode>(WhiteBalanceMode::AWB_MODE_SHADE + 1));
248     int32_t wb = 1;
249     AddOrUpdateMetadata(meta, OHOS_CONTROL_SENSOR_WB_VALUE, &wb, 1);
250     session->GetWhiteBalance(wb);
251 }
252 
TestGetMetadata()253 void TestGetMetadata()
254 {
255     auto cameras = manager->GetSupportedCameras();
256     sptr<CameraDevice> phyCam;
257     for (auto item : cameras) {
258         if (item->GetCameraType() == CAMERA_TYPE_WIDE_ANGLE) {
259             phyCam = item;
260         }
261     }
262     CHECK_ERROR_RETURN_LOG(cameras.empty(), "TimeLapsePhotoSessionFuzzer: No Wide Angle Camera");
263     string cameraId = phyCam->GetID();
264     MEDIA_INFO_LOG("TimeLapsePhotoSessionFuzzer: Wide Angle Camera Id = %{public}s", cameraId.c_str());
265     auto meta = make_shared<OHOS::Camera::CameraMetadata>(10, 100);
266     size_t delimPos = cameraId.find("/");
267     cameraId = cameraId.substr(delimPos + 1);
268     auto index = atoi(cameraId.c_str());
269     MEDIA_INFO_LOG("TimeLapsePhotoSessionFuzzer: Wide Angle Camera Id = %{public}d", index);
270     AddOrUpdateMetadata(meta, OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &index, 1);
271     session->ProcessPhysicalCameraSwitch(meta);
272     session->GetMetadata();
273 }
274 
TestGetMetadata2()275 void TestGetMetadata2()
276 {
277     sptr<ICaptureSession> iCaptureSession;
278     {
279         sptr<CaptureSession> captureSession = manager->CreateCaptureSession(sceneMode);
280         iCaptureSession = captureSession->GetCaptureSession();
281     }
282     vector<sptr<CameraDevice>> devices{};
283     sptr<TimeLapsePhotoSession> tlpSession = new TimeLapsePhotoSession(iCaptureSession, devices);
284     tlpSession->BeginConfig();
285     sptr<CaptureInput> input = manager->CreateCameraInput(camera);
286     tlpSession->AddInput(input);
287     tlpSession->GetMetadata();
288     tlpSession->Release();
289 }
290 
Test2()291 void Test2()
292 {
293     CaptureSessionCallback callback(session);
294     callback.OnError(1);
295     auto s = manager->CreateCaptureSession(SceneMode::VIDEO);
296     s->BeginConfig();
297     auto cap = s->GetCameraOutputCapabilities(camera)[0];
298     auto vp = cap->GetVideoProfiles()[0];
299     sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
300     auto vo = manager->CreateVideoOutput(vp, surface);
301     sptr<CaptureOutput> output = static_cast<CaptureOutput*>(vo.GetRefPtr());
302     s->AddOutput(output);
303     const int32_t N_30 = 30;
304     const int32_t N_60 = 60;
305     const int32_t N_200 = 200;
306     vo->SetFrameRateRange(N_30, N_30);
307     s->CanSetFrameRateRangeForOutput(N_30, N_30, output);
308     vo->SetFrameRateRange(N_30, N_60);
309     s->CanSetFrameRateRangeForOutput(N_30, N_60, output);
310     s->CanSetFrameRateRangeForOutput(1, N_200, output);
311 
312     Profile p = cap->GetPreviewProfiles()[0];
313     output = manager->CreatePreviewOutput(p, Surface::CreateSurfaceAsConsumer());
314     output->AddTag(CaptureOutput::DYNAMIC_PROFILE);
315     s->AddOutput(output);
316     surface = Surface::CreateSurfaceAsConsumer();
317     output = manager->CreateVideoOutput(vp, surface);
318     output->AddTag(CaptureOutput::DYNAMIC_PROFILE);
319     s->AddOutput(output);
320     s->Release();
321 
322     s = manager->CreateCaptureSession(SceneMode::CAPTURE);
323     s->BeginConfig();
324     sptr<IConsumerSurface> cs = IConsumerSurface::Create();
325     sptr<IBufferProducer> bp = cs->GetProducer();
326     p = cap->GetPhotoProfiles()[0];
327     output = manager->CreatePhotoOutput(p, bp);
328     output->AddTag(CaptureOutput::DYNAMIC_PROFILE);
329     s->AddOutput(output);
330 
331     output = manager->CreateMetadataOutput();
332     s->AddOutput(output);
333     output = manager->CreateMetadataOutput();
334     output->AddTag(CaptureOutput::DYNAMIC_PROFILE);
335     s->AddOutput(output);
336     s->Release();
337 }
338 
Test31(sptr<CaptureSession> s)339 void Test31(sptr<CaptureSession> s)
340 {
341     s->UnlockForControl();
342     bool supported = true;
343     bool configed = true;
344     set<camera_face_detect_mode_t> metadataObjectTypes{};
345     s->SetCaptureMetadataObjectTypes(metadataObjectTypes);
346     metadataObjectTypes.emplace(OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE);
347     s->SetCaptureMetadataObjectTypes(metadataObjectTypes);
348     s->EnableFaceDetection(supported);
349     const float distance = 1.0f;
350     s->IsSessionStarted();
351     s->EnableMovingPhotoMirror(supported, configed);
352     vector<WhiteBalanceMode> modes;
353     s->GetSupportedWhiteBalanceModes(modes);
354     s->IsWhiteBalanceModeSupported(WhiteBalanceMode::AWB_MODE_AUTO, supported);
355     s->LockForControl();
356     s->SetFocusDistance(distance);
357 
358     s->EnableLowLightDetection(supported);
359     s->EnableMovingPhoto(supported);
360     s->SetSensorSensitivity(1);
361     s->SetWhiteBalanceMode(WhiteBalanceMode::AWB_MODE_AUTO);
362     WhiteBalanceMode mode;
363     s->GetWhiteBalanceMode(mode);
364     vector<int32_t> whiteBalanceRange;
365     s->GetManualWhiteBalanceRange(whiteBalanceRange);
366     s->IsManualWhiteBalanceSupported(supported);
367     int32_t wbValue;
368     s->GetManualWhiteBalance(wbValue);
369     s->SetManualWhiteBalance(wbValue);
370     vector<std::vector<float>> supportedPhysicalApertures;
371     s->GetSupportedPhysicalApertures(supportedPhysicalApertures);
372     vector<float> apertures;
373     s->GetSupportedVirtualApertures(apertures);
374     s->GetSupportedPortraitEffects();
375     float aperture;
376     s->GetVirtualAperture(aperture);
377     s->SetVirtualAperture(aperture);
378     s->GetPhysicalAperture(aperture);
379     s->SetPhysicalAperture(aperture);
380     s->IsLcdFlashSupported();
381     s->EnableLcdFlash(supported);
382     s->EnableLcdFlashDetection(supported);
383     auto callback = s->GetLcdFlashStatusCallback();
384     s->SetLcdFlashStatusCallback(callback);
385     s->IsTripodDetectionSupported();
386     s->EnableTripodStabilization(supported);
387     s->EnableTripodDetection(supported);
388 }
389 
Test3()390 void Test3()
391 {
392     sptr<CaptureInput> input = manager->CreateCameraInput(camera);
393     input->Open();
394     auto s = manager->CreateCaptureSession(SceneMode::SECURE);
395     s->BeginConfig();
396     auto cap = manager->GetSupportedOutputCapability(camera, SceneMode::CAPTURE);
397     if (!cap->GetDepthProfiles().empty()) {
398         DepthProfile dp = cap->GetDepthProfiles()[0];
399         sptr<IConsumerSurface> cs = IConsumerSurface::Create();
400         sptr<IBufferProducer> bp = cs->GetProducer();
401         sptr<CaptureOutput> output = manager->CreateDepthDataOutput(dp, bp);
402         s->AddSecureOutput(output);
403     }
404     sptr<CaptureOutput> output = manager->CreateMetadataOutput();
405     s->AddOutput(output);
406     s->AddInput(input);
407     s->CommitConfig();
408     s->Start();
409     string deviceClass{"device/0"};
410     s->SetPreviewRotation(deviceClass);
411     uint32_t value = 1;
412     auto meta = s->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
413     AddOrUpdateMetadata(meta, OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &value, 1);
414     s->GetActiveVideoStabilizationMode();
415     s->UnlockForControl();
416     s->SetExposureMode(ExposureMode::EXPOSURE_MODE_AUTO);
417     s->LockForControl();
418     s->SetExposureMode(ExposureMode::EXPOSURE_MODE_AUTO);
419     s->GetSupportedFlashModes();
420     vector<FlashMode> flashModes;
421     s->GetSupportedFlashModes(flashModes);
422     s->GetFlashMode();
423     FlashMode flashMode;
424     s->GetFlashMode(flashMode);
425     s->SetFlashMode(flashMode);
426     s->IsFlashModeSupported(flashMode);
427     bool supported;
428     s->IsFlashModeSupported(flashMode, supported);
429     s->HasFlash();
430     s->HasFlash(supported);
431     meta = camera->GetMetadata();
432     AddOrUpdateMetadata(meta, OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL, &value, 0);
433     AddOrUpdateMetadata(meta, OHOS_ABILITY_SCENE_ZOOM_CAP, &value, 1);
434     vector<float> zoomRatioRange;
435     s->GetZoomRatioRange(zoomRatioRange);
436     Test31(s);
437     s->Stop();
438     s->Release();
439 }
440 
TestMetadataResultProcessor()441 void TestMetadataResultProcessor()
442 {
443     auto s = manager->CreateCaptureSession(SceneMode::CAPTURE);
444     s->BeginConfig();
445     sptr<CaptureOutput> output = manager->CreateMetadataOutput();
446     s->AddOutput(output);
447     sptr<CaptureInput> input = manager->CreateCameraInput(camera);
448     input->Open();
449     s->AddInput(input);
450     CaptureSession::CaptureSessionMetadataResultProcessor processor(s);
451     auto metadata = make_shared<OHOS::Camera::CameraMetadata>(10, 100);
452     uint64_t data = 1;
453     AddOrUpdateMetadata(metadata, OHOS_CONTROL_EXPOSURE_STATE, &data, 1);
454     AddOrUpdateMetadata(metadata, OHOS_CONTROL_FOCUS_MODE, &data, 1);
455     AddOrUpdateMetadata(metadata, OHOS_CONTROL_FOCUS_STATE, &data, 1);
456     AddOrUpdateMetadata(metadata, OHOS_CAMERA_MACRO_STATUS, &data, 1);
457     AddOrUpdateMetadata(metadata, FEATURE_MOON_CAPTURE_BOOST, &data, 1);
458     AddOrUpdateMetadata(metadata, OHOS_STATUS_MOON_CAPTURE_DETECTION, &data, 1);
459     AddOrUpdateMetadata(metadata, FEATURE_LOW_LIGHT_BOOST, &data, 1);
460     AddOrUpdateMetadata(metadata, OHOS_STATUS_LOW_LIGHT_DETECTION, &data, 1);
461     AddOrUpdateMetadata(metadata, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &data, 1);
462     AddOrUpdateMetadata(metadata, OHOS_STATUS_SENSOR_EXPOSURE_TIME, &data, 1);
463     AddOrUpdateMetadata(metadata, OHOS_CAMERA_EFFECT_SUGGESTION_TYPE, &data, 1);
464     AddOrUpdateMetadata(metadata, OHOS_STATUS_LCD_FLASH_STATUS, &data, 1);
465     processor.ProcessCallbacks(1, metadata);
466     s->Release();
467 }
468 
Test(uint8_t * rawData,size_t size)469 void Test(uint8_t *rawData, size_t size)
470 {
471     if (rawData == nullptr || size < LIMITSIZE) {
472         return;
473     }
474     GetPermission();
475     manager = CameraManager::GetInstance();
476     sptr<CaptureSession> captureSession = manager->CreateCaptureSession(sceneMode);
477     session = reinterpret_cast<TimeLapsePhotoSession*>(captureSession.GetRefPtr());
478     session->BeginConfig();
479     auto cameras = manager->GetSupportedCameras();
480     CHECK_AND_RETURN_LOG(cameras.size() >= NUM_2, "TimeLapsePhotoSessionFuzzer: GetSupportedCameras Error");
481     camera = cameras[0];
482     CHECK_AND_RETURN_LOG(camera, "TimeLapsePhotoSessionFuzzer: Camera is null");
483     sptr<CaptureInput> input = manager->CreateCameraInput(camera);
484     CHECK_AND_RETURN_LOG(input, "TimeLapsePhotoSessionFuzzer: CreateCameraInput Error");
485     input->Open();
486     session->AddInput(input);
487     AddOutput();
488     session->CommitConfig();
489     TestProcessor(rawData, size);
490     TestTimeLapsePhoto();
491     TestManualExposure(rawData, size);
492     TestManualIso();
493     TestWhiteBalance();
494     TestGetMetadata();
495     session->Release();
496     TestGetMetadata2();
497 }
498 
499 } // namespace StreamRepeatStubFuzzer
500 } // namespace CameraStandard
501 } // namespace OHOS
502 
503 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(uint8_t * data,size_t size)504 extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size)
505 {
506     /* Run your code on data */
507     OHOS::CameraStandard::TimeLapsePhotoSessionFuzzer::Test(data, size);
508     return 0;
509 }