1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 "hdi_common_v1_3.h"
17 #include "camera.h"
18 #include "video_key_info.h"
19 constexpr uint32_t ITEM_CAPACITY = 100;
20 constexpr uint32_t DATA_CAPACITY = 2000;
21 constexpr uint32_t DATA_COUNT = 1;
22 constexpr uint32_t FPS_COUNT = 2;
23 constexpr uint32_t CHECK_AREA_COUNT = 4;
24 constexpr uint32_t STREAMINFO_WIDTH = 1920;
25 constexpr uint32_t STREAMINFO_HEIGHT = 1080;
26 constexpr uint32_t HIGH_RESOLUTION_PHOTO_WIDTH = 8192;
27 constexpr uint32_t HIGH_RESOLUTION_PHOTO_HEIGHT = 6144;
28 namespace OHOS::Camera {
29 Test::ResultCallback Test::resultCallback_ = 0;
30 Test::StreamResultCallback Test::streamResultCallback_ = 0;
31 OHOS::HDI::Camera::V1_0::FlashlightStatus Test::statusCallback =
32 static_cast<OHOS::HDI::Camera::V1_0::FlashlightStatus>(0);
GetCurrentLocalTimeStamp()33 uint64_t Test::GetCurrentLocalTimeStamp()
34 {
35 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
36 std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
37 auto tmp = std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
38 return static_cast<uint64_t>(tmp.count());
39 }
40
DumpImageFile(int streamId,std::string suffix,const void * buffer,int32_t size)41 int32_t Test::DumpImageFile(int streamId, std::string suffix, const void* buffer, int32_t size)
42 {
43 if (imageDataSaveSwitch == SWITCH_OFF) {
44 return 0;
45 }
46 if (streamId < 0) {
47 CAMERA_LOGE("ivalid stream id: %{public}d", streamId);
48 return -1;
49 }
50 char mkdirCmd[PATH_MAX] = {0};
51 char path[PATH_MAX] = {0};
52 int ret = sprintf_s(mkdirCmd, sizeof(mkdirCmd) / sizeof(mkdirCmd[0]),
53 "mkdir -p /data/stream-%d", streamId);
54 if (ret < 0) {
55 return -1;
56 }
57 system(mkdirCmd);
58 ret = sprintf_s(path, sizeof(path) / sizeof(path[0]), "/data/stream-%d/%lld.%s",
59 streamId, GetCurrentLocalTimeStamp(), suffix.c_str());
60 if (ret < 0) {
61 return -1;
62 }
63
64 int imgFd = open(path, O_RDWR | O_CREAT, 00766);
65 if (imgFd == -1) {
66 CAMERA_LOGE("open file failed, errno: %{public}s", strerror(errno));
67 return -1;
68 }
69
70 ret = write(imgFd, buffer, size);
71 if (ret == -1) {
72 CAMERA_LOGE("write file failed, error: %{public}s", strerror(errno));
73 close(imgFd);
74 return -1;
75 }
76 close(imgFd);
77 return 0;
78 }
79
Init()80 void Test::Init()
81 {
82 uint32_t mainVer;
83 uint32_t minVer;
84 int32_t ret;
85 if (serviceV1_3 == nullptr) {
86 serviceV1_3 = OHOS::HDI::Camera::V1_3::ICameraHost::Get("camera_service", false);
87 EXPECT_NE(serviceV1_3, nullptr);
88 CAMERA_LOGI("V1_2::ICameraHost get success");
89 ret = serviceV1_3->GetVersion(mainVer, minVer);
90 EXPECT_EQ(ret, 0);
91 CAMERA_LOGI("V1_2::ICameraHost get version success, %{public}d, %{public}d", mainVer, minVer);
92 }
93
94 hostCallback = new TestCameraHostCallback();
95 ret = serviceV1_3->SetCallback(hostCallback);
96 EXPECT_EQ(ret, 0);
97 serviceV1_3->GetCameraIds(cameraIds);
98 if (cameraIds.size() <= CAMERA_ID_NUM) {
99 CAMERA_LOGE("camera device list empty");
100 GTEST_SKIP() << "No Camera Available" << std::endl;
101 return;
102 }
103 }
104
Open(int cameraId)105 void Test::Open(int cameraId)
106 {
107 if (cameraDeviceV1_3 == nullptr) {
108 if (cameraIds.size() <= CAMERA_ID_NUM) {
109 CAMERA_LOGE("camera device list empty");
110 GTEST_SKIP() << "No Camera Available" << std::endl;
111 return;
112 }
113 EXPECT_NE(serviceV1_3, nullptr);
114 EXPECT_NE(cameraIds.size(), 0);
115 GetCameraMetadata(cameraId);
116 deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
117
118 EXPECT_NE(serviceV1_3, nullptr);
119 if (DEVICE_1 == cameraId) {
120 rc = serviceV1_3->OpenCamera_V1_3(cameraIds[1], deviceCallback, cameraDeviceV1_3);
121 } else {
122 rc = serviceV1_3->OpenCamera_V1_3(cameraIds[0], deviceCallback, cameraDeviceV1_3);
123 }
124 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
125 EXPECT_NE(cameraDeviceV1_3, nullptr);
126 CAMERA_LOGI("OpenCamera V1_2 success");
127 }
128 }
129
OpenSecureCamera(int cameraId)130 void Test::OpenSecureCamera(int cameraId)
131 {
132 if (cameraDeviceV1_3 == nullptr) {
133 serviceV1_3->GetCameraIds(cameraIds);
134 if (cameraIds.size() <= CAMERA_ID_NUM) {
135 CAMERA_LOGE("camera device list empty");
136 GTEST_SKIP() << "No Camera Available" << std::endl;
137 return;
138 }
139 EXPECT_NE(serviceV1_3, nullptr);
140 EXPECT_NE(cameraIds.size(), 0);
141 GetCameraMetadata(cameraId);
142 deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
143
144 EXPECT_NE(serviceV1_3, nullptr);
145 if (DEVICE_1 == cameraId) {
146 rc = serviceV1_3->OpenSecureCamera(cameraIds[1], deviceCallback, cameraDeviceV1_3);
147 } else {
148 rc = serviceV1_3->OpenSecureCamera(cameraIds[0], deviceCallback, cameraDeviceV1_3);
149 }
150 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
151 EXPECT_NE(cameraDeviceV1_3, nullptr);
152 CAMERA_LOGI("OpenSecureCamera success");
153 }
154 }
155
156
GetCameraMetadata(int cameraId)157 void Test::GetCameraMetadata(int cameraId)
158 {
159 if (DEVICE_1 == cameraId) {
160 rc = serviceV1_3->GetCameraAbility(cameraIds[1], abilityVec);
161 } else {
162 rc = serviceV1_3->GetCameraAbility(cameraIds[0], abilityVec);
163 }
164 if (rc != HDI::Camera::V1_0::NO_ERROR) {
165 CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc);
166 }
167 MetadataUtils::ConvertVecToMetadata(abilityVec, ability);
168 EXPECT_NE(ability, nullptr);
169 }
170
PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag)171 void Test::PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag)
172 {
173 common_metadata_header_t* data = ability->get();
174 camera_metadata_item_t entry;
175 int ret = FindCameraMetadataItem(data, tag, &entry);
176 EXPECT_EQ(ret, 0);
177 EXPECT_NE(entry.count, 0);
178 std::cout << "----tag = " << tag << "count = " << entry.count << std::endl;
179 for (int i = 0; i < entry.count; i++) {
180 int v = entry.data.u8[i];
181 std::cout << "tag[" << tag << "][" << i << "] = " << v << std::endl;
182 }
183 std::cout << "--------------------------------" << std::endl;
184 }
185
Close()186 void Test::Close()
187 {
188 if (cameraDeviceV1_3 != nullptr) {
189 cameraDeviceV1_3->Close();
190 cameraDeviceV1_3 = nullptr;
191 }
192 }
193
DefaultPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)194 void Test::DefaultPreview(
195 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
196 {
197 infos->v1_0.streamId_ = streamIdPreview;
198 infos->v1_0.width_ = previewWidth;
199 infos->v1_0.height_ = previewHeight;
200 infos->v1_0.format_ = previewFormat;
201 infos->v1_0.dataspace_ = UT_DATA_SIZE;
202 infos->v1_0.intent_ = StreamIntent::PREVIEW;
203 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
204 }
205
DefaultCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)206 void Test::DefaultCapture(
207 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
208 {
209 infos->v1_0.streamId_ = streamIdCapture;
210 infos->v1_0.width_ = captureWidth;
211 infos->v1_0.height_ = captureHeight;
212 infos->v1_0.format_ = snapshotFormat;
213 infos->v1_0.dataspace_ = UT_DATA_SIZE;
214 infos->v1_0.intent_ = StreamIntent::STILL_CAPTURE;
215 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
216 }
217
CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)218 void Test::CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)
219 {
220 // Get stream operator
221 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
222 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
223 cameraTest->streamOperator_V1_3);
224 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
225 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
226 // Preview streamInfo
227 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
228 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
229 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
230 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
231 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
232 // Video streamInfo
233 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
234 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
235 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
236 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
237 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
238 // Create and commitStream
239 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
240 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
241 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
242 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE),
243 cameraTest->abilityVec);
244 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
245 }
246
CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)247 void Test::CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)
248 {
249 // Get stream operator
250 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
251 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
252 cameraTest->streamOperator_V1_3);
253 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
254 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
255 // Preview streamInfo
256 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
257 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
258 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
259 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
260 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
261 // Video streamInfo
262 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
263 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
264 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
265 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
266 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
267 // Create and commitStream
268 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
269 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
270 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
271 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SLOW_MOTION),
272 cameraTest->abilityVec);
273 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
274 }
275
UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)276 void Test::UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)
277 {
278 // Update settings
279 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
280 int32_t valueInvalid[2] = {240, 240};
281 float motionCheckArea[4] = {1, 1, 1, 1};
282 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &valueInvalid, FPS_COUNT);
283 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION_CHECK_AREA, &motionCheckArea, CHECK_AREA_COUNT);
284 std::vector<uint8_t> setting;
285 MetadataUtils::ConvertMetadataToVec(meta, setting);
286 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
287 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
288 int32_t slowMotionControl = OHOS_CAMERA_MOTION_DETECTION_ENABLE;
289 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION, &slowMotionControl, DATA_COUNT);
290 MetadataUtils::ConvertMetadataToVec(meta, setting);
291 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
292 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
293
294 // Start capture
295 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
296 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
297 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
298 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
299 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
300 }
301
SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)302 void Test::SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)
303 {
304 if (cameraTest->deviceCallback->resultMeta == nullptr) {
305 CAMERA_LOGI("callback not triggered");
306 return;
307 }
308 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
309 EXPECT_NE(data, nullptr);
310 camera_metadata_item_t entry;
311 cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_SLOW_MOTION_DETECTION, &entry);
312 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
313 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
314 uint8_t value = entry.data.u8[0];
315 // Detect the state of super slow motion
316 if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_DISABLE) {
317 CAMERA_LOGI("slow motion status is disabled");
318 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_READY) {
319 CAMERA_LOGI("slow motion status is ready");
320 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_START) {
321 CAMERA_LOGI("slow motion status is started");
322 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_RECORDING) {
323 CAMERA_LOGI("slow motion status is recording");
324 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_FINISH) {
325 CAMERA_LOGI("slow motion status is finished");
326 }
327 }
328 }
329
startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)330 void Test::startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)
331 {
332 // Get stream operator
333 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
334 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
335 cameraTest->streamOperator_V1_3);
336 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
337 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
338
339 // Preview streamInfo
340 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
341 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
342 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
343
344 // Capture streamInfo
345 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
346 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
347 cameraTest->streamInfoCapture->v1_0.width_ = HIGH_RESOLUTION_PHOTO_WIDTH;
348 cameraTest->streamInfoCapture->v1_0.height_ = HIGH_RESOLUTION_PHOTO_HEIGHT;
349 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
350
351 // Create and commit streams
352 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
353 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
354 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
355 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO),
356 cameraTest->abilityVec);
357 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
358 }
359
CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)360 void Test::CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,
361 std::shared_ptr<OHOS::Camera::Test> cameraTest)
362 {
363 printf("Enter CaptureByColorSpacesWithUpdateStreams function!\n");
364 if (!captureColorSpaces.empty()) {
365 // Clear infos
366 cameraTest->streamInfosV1_1.clear();
367 // Preview streamInfo
368 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
369 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
370 cameraTest->streamInfoV1_1->v1_0.dataspace_ = captureColorSpaces[0];
371 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
372 // Capture streamInfo
373 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
374 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
375 cameraTest->streamInfoCapture->v1_0.dataspace_ = captureColorSpaces[0];
376 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
377
378 // StreamInfosV1_1 should not be empty
379 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
380 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
381 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
382 OHOS::HDI::Camera::V1_1::OperationMode_V1_1::NORMAL, cameraTest->abilityVec);
383 // Start without colorspace setting
384 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
385 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
386
387 for (int32_t colorSpaces : captureColorSpaces) {
388 printf("capture colorSpaces value %d\n", colorSpaces);
389 // CancelCapture
390 cameraTest->streamOperator_V1_3->CancelCapture(cameraTest->captureIdPreview);
391 // Clear infos
392 cameraTest->streamInfosV1_1.clear();
393 // Preview streamInfo
394 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
395 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
396 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
397 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
398 // Capture streamInfo
399 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
400 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
401 cameraTest->streamInfoCapture->v1_0.dataspace_ = colorSpaces;
402 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
403 // UpdateStreams
404 cameraTest->rc = cameraTest->streamOperator_V1_3->UpdateStreams(cameraTest->streamInfosV1_1);
405 // Capture
406 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
407 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
408 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
409 sleep(UT_SECOND_TIMES);
410 }
411
412 // StopStream
413 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
414 }
415 }
416
DefaultSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)417 void Test::DefaultSketch(
418 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
419 {
420 infos->v1_0.streamId_ = streamIdSketch;
421 infos->v1_0.width_ = sketchWidth;
422 infos->v1_0.height_ = sketchHeight;
423 infos->v1_0.format_ = previewFormat;
424 infos->v1_0.dataspace_ = UT_DATA_SIZE;
425 infos->v1_0.intent_ = StreamIntent::PREVIEW;
426 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
427 }
428
DefaultInfosSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)429 void Test::DefaultInfosSketch(
430 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
431 {
432 DefaultSketch(infos);
433 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
434 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
435 DumpImageFile(streamIdSketch, "yuv", addr, size);
436 });
437 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
438 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
439 }
440
DefaultInfosPreviewV1_2(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)441 void Test::DefaultInfosPreviewV1_2(
442 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
443 {
444 DefaultPreview(infos);
445 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
446 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
447 DumpImageFile(streamIdPreview, "yuv", addr, size);
448 });
449 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
450 }
451
DefaultInfosPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)452 void Test::DefaultInfosPreview(
453 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
454 {
455 DefaultPreview(infos);
456 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
457 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
458 DumpImageFile(streamIdPreview, "yuv", addr, size);
459 });
460 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
461 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
462 }
463
DefaultInfosCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)464 void Test::DefaultInfosCapture(
465 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
466 {
467 DefaultCapture(infos);
468 std::shared_ptr<StreamConsumer> consumer_capture = std::make_shared<StreamConsumer>();
469 infos->v1_0.bufferQueue_ = consumer_capture->CreateProducerSeq([this](void* addr, uint32_t size) {
470 DumpImageFile(streamIdCapture, "jpeg", addr, size);
471 });
472 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
473 consumerMap_[StreamIntent::STILL_CAPTURE] = consumer_capture;
474 }
475
DefaultInfosProfessionalCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)476 void Test::DefaultInfosProfessionalCapture(
477 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
478 {
479 DefaultCapture(infos);
480 std::shared_ptr<StreamConsumer> consumer_capture = std::make_shared<StreamConsumer>();
481 infos->v1_0.bufferQueue_ = consumer_capture->CreateProducerSeq([this](void* addr, uint32_t size) {
482 DumpImageFile(streamIdCapture, "yuv", addr, size);
483 });
484 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
485 consumerMap_[StreamIntent::STILL_CAPTURE] = consumer_capture;
486 }
487
DefaultInfosVideo(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)488 void Test::DefaultInfosVideo(
489 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
490 {
491 infos->v1_0.streamId_ = streamIdVideo;
492 infos->v1_0.width_ = videoWidth;
493 infos->v1_0.height_ = videoHeight;
494 infos->v1_0.format_ = videoFormat;
495 infos->v1_0.dataspace_ = UT_DATA_SIZE;
496 infos->v1_0.intent_ = StreamIntent::VIDEO;
497 infos->v1_0.encodeType_ = ENCODE_TYPE_H265;
498 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
499 std::shared_ptr<StreamConsumer> consumer_video = std::make_shared<StreamConsumer>();
500 infos->v1_0.bufferQueue_ = consumer_video->CreateProducerSeq([this](void* addr, uint32_t size) {
501 DumpImageFile(streamIdVideo, "yuv", addr, size);
502 });
503 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
504 consumerMap_[StreamIntent::VIDEO] = consumer_video;
505 }
506
DefaultInfosAnalyze(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)507 void Test::DefaultInfosAnalyze(
508 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
509 {
510 infos->v1_0.streamId_ = streamIdAnalyze;
511 infos->v1_0.width_ = analyzeWidth;
512 infos->v1_0.height_ = analyzeHeight;
513 infos->v1_0.format_ = analyzeFormat;
514 infos->v1_0.dataspace_ = UT_DATA_SIZE;
515 infos->v1_0.intent_ = StreamIntent::ANALYZE;
516 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
517
518 std::shared_ptr<StreamConsumer> consumer_analyze = std::make_shared<StreamConsumer>();
519 infos->v1_0.bufferQueue_ = consumer_analyze->CreateProducerSeq([this](void* addr, uint32_t size) {
520 common_metadata_header_t *data = static_cast<common_metadata_header_t *>(addr);
521 camera_metadata_item_t entry = {};
522
523 int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry);
524 if (ret == 0) {
525 for (size_t i = 0; i < entry.count; i++) {
526 int id = entry.data.i32[i];
527 CAMERA_LOGI("Face ids : %{public}d", id);
528 }
529 }
530
531 ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry);
532 if (ret == 0) {
533 for (size_t i = 0; i < entry.count; i++) {
534 int id = entry.data.i32[i];
535 CAMERA_LOGI("Face rectangles : %{public}d", id);
536 }
537 }
538 });
539 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
540 consumerMap_[StreamIntent::ANALYZE] = consumer_analyze;
541 }
542
StartProfessionalStream(std::vector<StreamIntent> intents,uint8_t professionalMode)543 void Test::StartProfessionalStream(std::vector<StreamIntent> intents, uint8_t professionalMode)
544 {
545 streamOperatorCallbackV1_3 = new TestStreamOperatorCallbackV1_3();
546 uint32_t mainVersion = 1;
547 uint32_t minVersion = 0;
548 rc = cameraDeviceV1_3->GetStreamOperator_V1_3(streamOperatorCallbackV1_3, streamOperator_V1_3);
549 if (rc == HDI::Camera::V1_0::NO_ERROR) {
550 rc = streamOperator_V1_3->GetVersion(mainVersion, minVersion);
551 if (rc != HDI::Camera::V1_0::NO_ERROR) {
552 CAMERA_LOGE("streamOperator_V1_3 get version failed, rc = %{public}d", rc);
553 } else {
554 CAMERA_LOGI("streamOperator_V1_3 get version success, %{public}u, %{public}u",
555 mainVersion, minVersion);
556 }
557 CAMERA_LOGI("GetStreamOperator success");
558 } else {
559 CAMERA_LOGE("GetStreamOperator fail, rc = %{public}d", rc);
560 }
561 streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
562 streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
563 streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
564 streamInfoAnalyze = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
565
566 for (auto& streamType : intents) {
567 if (streamType == StreamIntent::PREVIEW) {
568 DefaultInfosPreview(streamInfoPre);
569 streamInfos.push_back(*streamInfoPre);
570 } else if (streamType == StreamIntent::VIDEO) {
571 DefaultInfosVideo(streamInfoVideo);
572 streamInfos.push_back(*streamInfoVideo);
573 } else if (streamType == StreamIntent::ANALYZE) {
574 DefaultInfosAnalyze(streamInfoAnalyze);
575 streamInfos.push_back(*streamInfoAnalyze);
576 } else {
577 DefaultInfosProfessionalCapture(streamInfoCapture);
578 streamInfos.push_back(*streamInfoCapture);
579 }
580 }
581
582 rc = streamOperator_V1_3->CreateStreams_V1_1(streamInfos);
583 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
584 rc = streamOperator_V1_3->CommitStreams_V1_1(
585 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(professionalMode),
586 abilityVec);
587 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
588 sleep(1);
589 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfos);
590 }
591
StartStream(std::vector<StreamIntent> intents,OHOS::HDI::Camera::V1_3::OperationMode mode)592 void Test::StartStream(std::vector<StreamIntent> intents, OHOS::HDI::Camera::V1_3::OperationMode mode)
593 {
594 streamOperatorCallbackV1_3 = new TestStreamOperatorCallbackV1_3();
595 uint32_t mainVersion = 1;
596 uint32_t minVersion = 0;
597 rc = cameraDeviceV1_3->GetStreamOperator_V1_3(streamOperatorCallbackV1_3, streamOperator_V1_3);
598 if (rc == HDI::Camera::V1_0::NO_ERROR) {
599 rc = streamOperator_V1_3->GetVersion(mainVersion, minVersion);
600 if (rc != HDI::Camera::V1_0::NO_ERROR) {
601 CAMERA_LOGE("streamOperator_V1_3 get version failed, rc = %{public}d", rc);
602 } else {
603 CAMERA_LOGI("streamOperator_V1_3 get version success, %{public}u, %{public}u",
604 mainVersion, minVersion);
605 }
606 CAMERA_LOGI("GetStreamOperator success");
607 } else {
608 CAMERA_LOGE("GetStreamOperator fail, rc = %{public}d", rc);
609 }
610 streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
611 streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
612 streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
613 streamInfoAnalyze = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
614
615 for (auto& intent : intents) {
616 if (intent == StreamIntent::PREVIEW) {
617 DefaultInfosPreview(streamInfoPre);
618 streamInfos.push_back(*streamInfoPre);
619 } else if (intent == StreamIntent::VIDEO) {
620 DefaultInfosVideo(streamInfoVideo);
621 streamInfos.push_back(*streamInfoVideo);
622 } else if (intent == StreamIntent::ANALYZE) {
623 DefaultInfosAnalyze(streamInfoAnalyze);
624 streamInfos.push_back(*streamInfoAnalyze);
625 } else {
626 DefaultInfosCapture(streamInfoCapture);
627 streamInfos.push_back(*streamInfoCapture);
628 }
629 }
630
631 rc = streamOperator_V1_3->CreateStreams_V1_1(streamInfos);
632 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
633 rc = streamOperator_V1_3->CommitStreams_V1_1(
634 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(mode), abilityVec);
635 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
636 sleep(1);
637 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfos);
638 }
639
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)640 void Test::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
641 {
642 captureInfo = std::make_shared<CaptureInfo>();
643 captureInfo->streamIds_ = {streamId};
644 captureInfo->captureSetting_ = abilityVec;
645 captureInfo->enableShutterCallback_ = shutterCallback;
646 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
647 rc = (CamRetCode)streamOperator_V1_3->Capture(captureId, *captureInfo, isStreaming);
648 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
649 if (rc == HDI::Camera::V1_0::NO_ERROR) {
650 CAMERA_LOGI("check Capture: Capture success, %{public}d", captureId);
651 } else {
652 std::cout << "rc = " << rc << std::endl;
653 CAMERA_LOGE("check Capture: Capture fail, rc = %{public}d", rc);
654 }
655 sleep(UT_SLEEP_TIME);
656 }
657
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)658 void Test::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
659 {
660 if (captureIds.size() > 0) {
661 for (auto &captureId : captureIds) {
662 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
663 rc = streamOperator_V1_3->CancelCapture(captureId);
664 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
665 if (rc == HDI::Camera::V1_0::NO_ERROR) {
666 CAMERA_LOGI("check Capture: CancelCapture success, %{public}d", captureId);
667 } else {
668 CAMERA_LOGE("check Capture: CancelCapture fail, rc = %{public}d, captureId = %{public}d",
669 rc, captureId);
670 }
671 }
672 }
673 if (streamIds.size() > 0) {
674 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
675 rc = streamOperator_V1_3->ReleaseStreams(streamIds);
676 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
677 if (rc == HDI::Camera::V1_0::NO_ERROR) {
678 CAMERA_LOGI("check Capture: ReleaseStream success");
679 } else {
680 CAMERA_LOGE("check Capture: ReleaseStreams fail, rc = %{public}d", rc);
681 }
682 }
683 }
684
CalculateFps(int64_t timestamp,int32_t streamId)685 void Test::StreamConsumer::CalculateFps(int64_t timestamp, int32_t streamId)
686 {
687 if (isFirstCalculateFps_) {
688 if ((timestamp - intervalTimestamp_) >= interval_) {
689 int64_t timeInterval = timestamp - intervalTimestamp_;
690 if (timeInterval != 0) {
691 float fps = (int64_t)(100000000000 * timestampCount_ / timeInterval) / 100.0;
692 CAMERA_LOGI("Calculate FPS success, streamId: %{public}d, Fps:%{public}f", streamId, fps);
693 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
694 } else {
695 CAMERA_LOGE("Calculate FPS error timeInerval is 0");
696 }
697 }
698 } else {
699 intervalTimestamp_ = timestamp;
700 isFirstCalculateFps_ = true;
701 }
702 if ((timestamp - intervalTimestamp_) >= ONESECOND_OF_MICROSECOND_UNIT * UT_SECOND_TIMES) {
703 intervalTimestamp_ = timestamp;
704 timestampCount_ = 0;
705 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
706 }
707 timestampCount_++;
708 }
709
GetTimeStamp(int64_t * g_timestamp,uint32_t lenght,int64_t timestamp,int32_t gotSize)710 void Test::StreamConsumer::GetTimeStamp(int64_t *g_timestamp, uint32_t lenght, int64_t timestamp, int32_t gotSize)
711 {
712 if (gotSize != UT_PREVIEW_SIZE) {
713 if (g_timestamp[0] == 0) {
714 g_timestamp[0] = timestamp;
715 } else {
716 g_timestamp[1] = timestamp;
717 }
718 }
719 }
720
CreateProducer(std::function<void (void *,uint32_t)> callback)721 OHOS::sptr<OHOS::IBufferProducer> Test::StreamConsumer::CreateProducer(std::function<void(void*, uint32_t)> callback)
722 {
723 consumer_ = OHOS::IConsumerSurface::Create();
724 if (consumer_ == nullptr) {
725 return nullptr;
726 }
727 sptr<IBufferConsumerListener> listener = new TestBufferConsumerListener();
728 consumer_->RegisterConsumerListener(listener);
729 auto producer = consumer_->GetProducer();
730 if (producer == nullptr) {
731 return nullptr;
732 }
733
734 callback_ = callback;
735 consumerThread_ = new std::thread([this, listener] {
736 int32_t flushFence = 0;
737 int64_t timestamp = 0;
738 OHOS::Rect damage;
739 TestBufferConsumerListener* checker = static_cast<TestBufferConsumerListener*>(listener.GetRefPtr());
740 while (running_ == true) {
741 OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr;
742 if (checker->checkBufferAvailable()) {
743 consumer_->AcquireBuffer(buffer, flushFence, timestamp, damage);
744 if (buffer != nullptr) {
745 void* addr = buffer->GetVirAddr();
746 uint32_t size = buffer->GetSize();
747 int32_t gotSize = 0;
748 int32_t isKey = 0;
749 int32_t streamId = 0;
750 int32_t captureId = 0;
751 buffer->GetExtraData()->ExtraGet(OHOS::Camera::dataSize, gotSize);
752 buffer->GetExtraData()->ExtraGet(OHOS::Camera::isKeyFrame, isKey);
753 buffer->GetExtraData()->ExtraGet(OHOS::Camera::timeStamp, timestamp);
754 buffer->GetExtraData()->ExtraGet(OHOS::Camera::streamId, streamId);
755 buffer->GetExtraData()->ExtraGet(OHOS::Camera::captureId, captureId);
756 GetTimeStamp(g_timestamp, sizeof(g_timestamp) / sizeof(g_timestamp[0]), timestamp, gotSize);
757 if (gotSize) {
758 CalculateFps(timestamp, streamId);
759 callback_(addr, gotSize);
760 } else {
761 callback_(addr, size);
762 }
763 consumer_->ReleaseBuffer(buffer, -1);
764 shotCount_--;
765 if (shotCount_ == 0) {
766 std::unique_lock<std::mutex> l(l_);
767 cv_.notify_one();
768 }
769 }
770 }
771 if (running_ == false) {
772 break;
773 }
774 usleep(1);
775 }
776 });
777
778 return producer;
779 }
780
CreateProducerSeq(std::function<void (void *,uint32_t)> callback)781 OHOS::sptr<BufferProducerSequenceable> Test::StreamConsumer::CreateProducerSeq(
782 std::function<void(void*, uint32_t)> callback)
783 {
784 OHOS::sptr<OHOS::IBufferProducer> producer = CreateProducer(callback);
785 if (producer == nullptr) {
786 return nullptr;
787 }
788
789 return new BufferProducerSequenceable(producer);
790 }
791
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)792 int32_t Test::TestStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
793 {
794 for (auto it : streamId) {
795 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
796 }
797 return HDI::Camera::V1_0::NO_ERROR;
798 }
799
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)800 int32_t Test::TestStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo> &infos)
801 {
802 for (auto it : infos) {
803 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
804 it.frameCount_);
805 }
806 return HDI::Camera::V1_0::NO_ERROR;
807 }
808
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)809 int32_t Test::TestStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo> &infos)
810 {
811 for (auto it : infos) {
812 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
813 it.error_);
814 }
815 return HDI::Camera::V1_0::NO_ERROR;
816 }
817
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)818 int32_t Test::TestStreamOperatorCallback::OnFrameShutter(int32_t captureId,
819 const std::vector<int32_t> &streamIds, uint64_t timestamp)
820 {
821 (void)timestamp;
822 for (auto it : streamIds) {
823 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
824 }
825 return HDI::Camera::V1_0::NO_ERROR;
826 }
827
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)828 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
829 {
830 return instanceImpl.OnCaptureStarted(captureId, streamId);
831 }
832
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)833 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureEnded(int32_t captureId,
834 const std::vector<CaptureEndedInfo> &infos)
835 {
836 return instanceImpl.OnCaptureEnded(captureId, infos);
837 }
838
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)839 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureError(int32_t captureId,
840 const std::vector<CaptureErrorInfo> &infos)
841 {
842 return instanceImpl.OnCaptureError(captureId, infos);
843 }
844
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)845 int32_t Test::TestStreamOperatorCallbackV1_2::OnFrameShutter(int32_t captureId,
846 const std::vector<int32_t> &streamIds, uint64_t timestamp)
847 {
848 return instanceImpl.OnFrameShutter(captureId, streamIds, timestamp);
849 }
850
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)851 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted_V1_2(int32_t captureId,
852 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
853 {
854 for (auto it : infos) {
855 CAMERA_LOGI("captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
856 }
857 return HDI::Camera::V1_0::NO_ERROR;
858 }
859
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)860 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
861 {
862 return instanceImpl.OnCaptureStarted(captureId, streamId);
863 }
864
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)865 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureEnded(int32_t captureId,
866 const std::vector<CaptureEndedInfo> &infos)
867 {
868 return instanceImpl.OnCaptureEnded(captureId, infos);
869 }
870
OnCaptureEndedExt(int32_t captureId,const std::vector<HDI::Camera::V1_3::CaptureEndedInfoExt> & infos)871 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureEndedExt(int32_t captureId,
872 const std::vector<HDI::Camera::V1_3::CaptureEndedInfoExt> &infos)
873 {
874 for (auto it : infos) {
875 CAMERA_LOGI("OnCaptureEndedExt captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
876 }
877 return HDI::Camera::V1_0::NO_ERROR;
878 }
879
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)880 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureError(int32_t captureId,
881 const std::vector<CaptureErrorInfo> &infos)
882 {
883 return instanceImpl.OnCaptureError(captureId, infos);
884 }
885
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)886 int32_t Test::TestStreamOperatorCallbackV1_3::OnFrameShutter(int32_t captureId,
887 const std::vector<int32_t> &streamIds, uint64_t timestamp)
888 {
889 (void)timestamp;
890 for (auto it : streamIds) {
891 CAMERA_LOGI("OnFrameShutter captureId: %{public}d, streamId: %{public}d", captureId, it);
892 }
893 return instanceImpl.OnFrameShutter(captureId, streamIds, timestamp);
894 }
895
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)896 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureStarted_V1_2(int32_t captureId,
897 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
898 {
899 return instanceImpl.OnCaptureStarted_V1_2(captureId, infos);
900 }
901
OnCaptureReady(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)902 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureReady(int32_t captureId,
903 const std::vector<int32_t> &streamIds, uint64_t timestamp)
904 {
905 (void)timestamp;
906 for (auto it : streamIds) {
907 CAMERA_LOGI("OnCaptureReady captureId: %{public}d, streamId: %{public}d", captureId, it);
908 }
909 return HDI::Camera::V1_0::NO_ERROR;
910 }
911
OnFrameShutterEnd(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)912 int32_t Test::TestStreamOperatorCallbackV1_3::OnFrameShutterEnd(int32_t captureId,
913 const std::vector<int32_t> &streamIds, uint64_t timestamp)
914 {
915 (void)timestamp;
916 for (auto it : streamIds) {
917 CAMERA_LOGI("OnFrameShutterEnd captureId: %{public}d, streamId: %{public}d", captureId, it);
918 }
919 return HDI::Camera::V1_0::NO_ERROR;
920 }
921
OnResult(int32_t streamId,const std::vector<uint8_t> & result)922 int32_t Test::TestStreamOperatorCallbackV1_3::OnResult(int32_t streamId, const std::vector<uint8_t> &result)
923 {
924 MetadataUtils::ConvertVecToMetadata(result, streamResultMeta);
925 if (Test::streamResultCallback_) {
926 Test::streamResultCallback_(streamId, streamResultMeta);
927 }
928 return HDI::Camera::V1_0::NO_ERROR;
929 }
930
OnError(ErrorType type,int32_t errorMsg)931 int32_t Test::DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg)
932 {
933 CAMERA_LOGE("type: %{public}d, errorMsg: %{public}d", type, errorMsg);
934 return HDI::Camera::V1_0::NO_ERROR;
935 }
936
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)937 int32_t Test::DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t> &result)
938 {
939 MetadataUtils::ConvertVecToMetadata(result, resultMeta);
940 if (Test::resultCallback_) {
941 Test::resultCallback_(timestamp, resultMeta);
942 }
943 return HDI::Camera::V1_0::NO_ERROR;
944 }
945
OnCameraStatus(const std::string & cameraId,CameraStatus status)946 int32_t Test::TestCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
947 {
948 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
949 return HDI::Camera::V1_0::NO_ERROR;
950 }
951
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)952 int32_t Test::TestCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
953 {
954 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
955 return HDI::Camera::V1_0::NO_ERROR;
956 }
957
OnCameraEvent(const std::string & cameraId,CameraEvent event)958 int32_t Test::TestCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
959 {
960 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
961 return HDI::Camera::V1_0::NO_ERROR;
962 }
963
OnCameraStatus(const std::string & cameraId,CameraStatus status)964 int32_t Test::TestCameraHostCallbackV1_2::OnCameraStatus(const std::string& cameraId, CameraStatus status)
965 {
966 return instanceImpl.OnCameraStatus(cameraId, status);
967 }
968
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)969 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
970 {
971 return instanceImpl.OnFlashlightStatus(cameraId, status);
972 }
973
OnCameraEvent(const std::string & cameraId,CameraEvent event)974 int32_t Test::TestCameraHostCallbackV1_2::OnCameraEvent(const std::string& cameraId, CameraEvent event)
975 {
976 return instanceImpl.OnCameraEvent(cameraId, event);
977 }
978
OnFlashlightStatus_V1_2(FlashlightStatus status)979 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus_V1_2(FlashlightStatus status)
980 {
981 CAMERA_LOGE("status: %{public}d", status);
982 Test::statusCallback = status;
983 return HDI::Camera::V1_0::NO_ERROR;
984 }
985 } // OHOS::Camera