1 /*
2 * Copyright (c) 2023-2025 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_2.h"
17 #include "camera.h"
18 #include "video_key_info.h"
19 int64_t OHOS::Camera::Test::StreamConsumer::g_timestamp[2] = {0};
20 namespace OHOS::Camera {
21 Test::ResultCallback Test::resultCallback_ = 0;
22 OHOS::HDI::Camera::V1_0::FlashlightStatus Test::statusCallback =
23 static_cast<OHOS::HDI::Camera::V1_0::FlashlightStatus>(0);
24 constexpr uint32_t LOOP_COUNT = 12;
GetCurrentLocalTimeStamp()25 uint64_t Test::GetCurrentLocalTimeStamp()
26 {
27 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
28 std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
29 auto tmp = std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
30 return static_cast<uint64_t>(tmp.count());
31 }
32
DumpImageFile(int streamId,std::string suffix,const void * buffer,int32_t size)33 int32_t Test::DumpImageFile(int streamId, std::string suffix, const void* buffer, int32_t size)
34 {
35 if (imageDataSaveSwitch == SWITCH_OFF) {
36 return 0;
37 }
38 if (streamId < 0) {
39 CAMERA_LOGE("ivalid stream id: %{public}d", streamId);
40 return -1;
41 }
42 char mkdirCmd[PATH_MAX] = {0};
43 char path[PATH_MAX] = {0};
44 int ret = sprintf_s(mkdirCmd, sizeof(mkdirCmd) / sizeof(mkdirCmd[0]),
45 "mkdir -p /data/stream-%d", streamId);
46 if (ret < 0) {
47 return -1;
48 }
49 system(mkdirCmd);
50 ret = sprintf_s(path, sizeof(path) / sizeof(path[0]), "/data/stream-%d/%lld.%s",
51 streamId, GetCurrentLocalTimeStamp(), suffix.c_str());
52 if (ret < 0) {
53 return -1;
54 }
55
56 int imgFd = open(path, O_RDWR | O_CREAT, 00766);
57 if (imgFd == -1) {
58 CAMERA_LOGE("open file failed, errno: %{public}s", strerror(errno));
59 return -1;
60 }
61
62 ret = write(imgFd, buffer, size);
63 if (ret == -1) {
64 CAMERA_LOGE("write file failed, error: %{public}s", strerror(errno));
65 close(imgFd);
66 return -1;
67 }
68 close(imgFd);
69 return 0;
70 }
71
Init()72 void Test::Init()
73 {
74 uint32_t mainVer;
75 uint32_t minVer;
76 int32_t ret;
77 if (serviceV1_2 == nullptr) {
78 serviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraHost::Get("camera_service", false);
79 if (serviceV1_2 == nullptr) {
80 int loopCount = 0;
81 do {
82 usleep(UT_MICROSECOND_TIMES);
83 serviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraHost::Get("camera_service", false);
84 loopCount++;
85 } while (loopCount <= LOOP_COUNT || serviceV1_2 == nullptr);
86 }
87 EXPECT_NE(serviceV1_2, nullptr);
88 CAMERA_LOGI("V1_2::ICameraHost get success");
89 ret = serviceV1_2->GetVersion(mainVer, minVer);
90 EXPECT_EQ(ret, 0);
91 CAMERA_LOGI("V1_2::ICameraHost get version success, %{public}d, %{public}d", mainVer, minVer);
92 service = static_cast<OHOS::HDI::Camera::V1_0::ICameraHost *>(serviceV1_2.GetRefPtr());
93 }
94
95 hostCallback = new TestCameraHostCallback();
96 ret = service->SetCallback(hostCallback);
97 EXPECT_EQ(ret, 0);
98 service->GetCameraIds(cameraIds);
99 if (cameraIds.size() <= CAMERA_ID_NUM) {
100 CAMERA_LOGE("camera device list empty");
101 GTEST_SKIP() << "No Camera Available" << std::endl;
102 return;
103 }
104 }
105
DefferredImageTestInit()106 int32_t Test::DefferredImageTestInit()
107 {
108 constexpr const char* serviceName = "camera_image_process_service";
109 constexpr const int userId = 100;
110 int ret = 0;
111
112 // get ImageProcessService
113 imageProcessService_ = OHOS::HDI::Camera::V1_2::ImageProcessServiceProxy::Get(serviceName, false);
114 if (imageProcessService_ == nullptr) {
115 CAMERA_LOGE("ImageProcessServiceProxy::Get Fail, imageProcessService is nullptr");
116 printf("ImageProcessServiceProxy::Get Fail, imageProcessService is nullptr");
117 return -1;
118 }
119 imageProcessCallback_ = new OHOS::Camera::Test::TestImageProcessCallback();
120 EXPECT_NE(imageProcessCallback_, nullptr);
121 ret = imageProcessService_->CreateImageProcessSession(userId, imageProcessCallback_, imageProcessSession_);
122 EXPECT_EQ(ret, 0);
123 if (imageProcessSession_ == nullptr) {
124 CAMERA_LOGE("CreateImageProcessSession Fail, imageProcessSession is nullptr: %{public}d", ret);
125 printf("CreateImageProcessSession Fail, imageProcessSession is nullptr: %d\r\n", ret);
126 return -1;
127 }
128 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(itemCapacity, dataCapacity);
129 int32_t cameraUserId = 100;
130 meta->addEntry(OHOS_CAMERA_USER_ID, &cameraUserId, dataCount);
131 std::vector<uint8_t> metaVec;
132 MetadataUtils::ConvertMetadataToVec(meta, metaVec);
133 cameraDevice->UpdateSettings(metaVec);
134 return 0;
135 }
136
Open(int cameraId)137 void Test::Open(int cameraId)
138 {
139 OpenCameraV1_2(cameraId);
140 }
141
OpenCameraV1_2(int cameraId)142 void Test::OpenCameraV1_2(int cameraId)
143 {
144 if (cameraDevice == nullptr) {
145 service->GetCameraIds(cameraIds);
146 if (cameraIds.size() <= CAMERA_ID_NUM) {
147 CAMERA_LOGE("camera device list empty");
148 GTEST_SKIP() << "No Camera Available" << std::endl;
149 return;
150 }
151 EXPECT_NE(service, nullptr);
152 EXPECT_NE(cameraIds.size(), 0);
153 GetCameraMetadata(cameraId);
154 deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
155
156 ASSERT_NE(serviceV1_2, nullptr);
157 if (cameraId == DEVICE_1) {
158 rc = serviceV1_2->OpenCamera_V1_2(cameraIds[1], deviceCallback, cameraDeviceV1_2);
159 } else {
160 rc = serviceV1_2->OpenCamera_V1_2(cameraIds[0], deviceCallback, cameraDeviceV1_2);
161 }
162 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
163 ASSERT_NE(cameraDeviceV1_2, nullptr);
164 cameraDevice = static_cast<OHOS::HDI::Camera::V1_0::ICameraDevice *>(cameraDeviceV1_2.GetRefPtr());
165 CAMERA_LOGI("OpenCamera V1_2 success");
166 }
167 }
168
GetCameraMetadata(int cameraId)169 void Test::GetCameraMetadata(int cameraId)
170 {
171 if (DEVICE_1 == cameraId) {
172 rc = service->GetCameraAbility(cameraIds[1], abilityVec);
173 } else {
174 rc = service->GetCameraAbility(cameraIds[0], abilityVec);
175 }
176 if (rc != HDI::Camera::V1_0::NO_ERROR) {
177 CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc);
178 }
179 MetadataUtils::ConvertVecToMetadata(abilityVec, ability);
180 EXPECT_NE(ability, nullptr);
181 }
182
Close()183 void Test::Close()
184 {
185 if (cameraDevice != nullptr) {
186 cameraDevice->Close();
187 cameraDevice = nullptr;
188 }
189 }
190
DefaultPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)191 void Test::DefaultPreview(
192 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
193 {
194 infos->v1_0.streamId_ = streamIdPreview;
195 infos->v1_0.width_ = previewWidth;
196 infos->v1_0.height_ = previewHeight;
197 infos->v1_0.format_ = previewFormat;
198 infos->v1_0.dataspace_ = UT_DATA_SIZE;
199 infos->v1_0.intent_ = StreamIntent::PREVIEW;
200 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
201 }
202
DefaultCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)203 void Test::DefaultCapture(
204 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
205 {
206 infos->v1_0.streamId_ = streamIdCapture;
207 infos->v1_0.width_ = captureWidth;
208 infos->v1_0.height_ = captureHeight;
209 infos->v1_0.format_ = snapshotFormat;
210 infos->v1_0.dataspace_ = UT_DATA_SIZE;
211 infos->v1_0.intent_ = StreamIntent::STILL_CAPTURE;
212 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
213 }
214
DefaultSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)215 void Test::DefaultSketch(
216 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
217 {
218 infos->v1_0.streamId_ = streamIdSketch;
219 infos->v1_0.width_ = sketchWidth;
220 infos->v1_0.height_ = sketchHeight;
221 infos->v1_0.format_ = previewFormat;
222 infos->v1_0.dataspace_ = UT_DATA_SIZE;
223 infos->v1_0.intent_ = StreamIntent::PREVIEW;
224 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
225 }
226
DefaultInfosSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)227 void Test::DefaultInfosSketch(
228 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
229 {
230 DefaultSketch(infos);
231 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
232 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
233 DumpImageFile(streamIdSketch, "yuv", addr, size);
234 });
235 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
236 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
237 }
238
DefaultInfosPreviewV1_2(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)239 void Test::DefaultInfosPreviewV1_2(
240 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
241 {
242 DefaultPreview(infos);
243 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
244 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
245 DumpImageFile(streamIdPreview, "yuv", addr, size);
246 });
247 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
248 }
249
DefaultInfosPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)250 void Test::DefaultInfosPreview(
251 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
252 {
253 DefaultPreview(infos);
254 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
255 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
256 DumpImageFile(streamIdPreview, "yuv", addr, size);
257 });
258 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
259 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
260 }
261
DefaultInfosCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)262 void Test::DefaultInfosCapture(
263 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
264 {
265 DefaultCapture(infos);
266 std::shared_ptr<StreamConsumer> consumer_capture = std::make_shared<StreamConsumer>();
267 infos->v1_0.bufferQueue_ = consumer_capture->CreateProducerSeq([this](void* addr, uint32_t size) {
268 DumpImageFile(streamIdCapture, "jpeg", addr, size);
269 });
270 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
271 consumerMap_[StreamIntent::STILL_CAPTURE] = consumer_capture;
272 }
273
DefaultInfosVideo(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)274 void Test::DefaultInfosVideo(
275 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
276 {
277 infos->v1_0.streamId_ = streamIdVideo;
278 infos->v1_0.width_ = videoWidth;
279 infos->v1_0.height_ = videoHeight;
280 infos->v1_0.format_ = videoFormat;
281 infos->v1_0.dataspace_ = UT_DATA_SIZE;
282 infos->v1_0.intent_ = StreamIntent::VIDEO;
283 infos->v1_0.encodeType_ = ENCODE_TYPE_H265;
284 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
285 std::shared_ptr<StreamConsumer> consumer_video = std::make_shared<StreamConsumer>();
286 infos->v1_0.bufferQueue_ = consumer_video->CreateProducerSeq([this](void* addr, uint32_t size) {
287 DumpImageFile(streamIdVideo, "yuv", addr, size);
288 });
289 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
290 consumerMap_[StreamIntent::VIDEO] = consumer_video;
291 }
292
DefaultInfosAnalyze(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)293 void Test::DefaultInfosAnalyze(
294 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
295 {
296 infos->v1_0.streamId_ = streamIdAnalyze;
297 infos->v1_0.width_ = analyzeWidth;
298 infos->v1_0.height_ = analyzeHeight;
299 infos->v1_0.format_ = analyzeFormat;
300 infos->v1_0.dataspace_ = UT_DATA_SIZE;
301 infos->v1_0.intent_ = StreamIntent::ANALYZE;
302 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
303
304 std::shared_ptr<StreamConsumer> consumer_analyze = std::make_shared<StreamConsumer>();
305 infos->v1_0.bufferQueue_ = consumer_analyze->CreateProducerSeq([this](void* addr, uint32_t size) {
306 common_metadata_header_t *data = static_cast<common_metadata_header_t *>(addr);
307 camera_metadata_item_t entry = {};
308
309 int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry);
310 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
311 for (size_t i = 0; i < entry.count; i++) {
312 int id = entry.data.i32[i];
313 CAMERA_LOGI("Face ids : %{public}d", id);
314 }
315 }
316
317 ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry);
318 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
319 for (size_t i = 0; i < entry.count; i++) {
320 int id = entry.data.i32[i];
321 CAMERA_LOGI("Face rectangles : %{public}d", id);
322 }
323 }
324 });
325 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
326 consumerMap_[StreamIntent::ANALYZE] = consumer_analyze;
327 }
328
StartStream(std::vector<StreamIntent> intents)329 void Test::StartStream(std::vector<StreamIntent> intents)
330 {
331 streamOperatorCallback = new TestStreamOperatorCallback();
332 uint32_t mainVersion = 1;
333 uint32_t minVersion = 0;
334 rc = cameraDeviceV1_2->GetStreamOperator_V1_1(streamOperatorCallback, streamOperator_V1_1);
335 if (rc == HDI::Camera::V1_0::NO_ERROR) {
336 rc = streamOperator_V1_1->GetVersion(mainVersion, minVersion);
337 streamOperator = static_cast<OHOS::HDI::Camera::V1_0::IStreamOperator *>(streamOperator_V1_1.GetRefPtr());
338 if (rc != HDI::Camera::V1_0::NO_ERROR) {
339 CAMERA_LOGE("StreamOperator V1_1 get version failed, rc = %{public}d", rc);
340 } else {
341 CAMERA_LOGI("StreamOperator V1_1 get version success, %{public}u, %{public}u",
342 mainVersion, minVersion);
343 }
344 CAMERA_LOGI("GetStreamOperator success");
345 } else {
346 CAMERA_LOGE("GetStreamOperator fail, rc = %{public}d", rc);
347 }
348 streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
349 streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
350 streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
351 streamInfoAnalyze = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
352
353 for (auto& intent : intents) {
354 if (intent == StreamIntent::PREVIEW) {
355 DefaultInfosPreview(streamInfoPre);
356 streamInfos.push_back(*streamInfoPre);
357 } else if (intent == StreamIntent::VIDEO) {
358 DefaultInfosVideo(streamInfoVideo);
359 streamInfos.push_back(*streamInfoVideo);
360 } else if (intent == StreamIntent::ANALYZE) {
361 DefaultInfosAnalyze(streamInfoAnalyze);
362 streamInfos.push_back(*streamInfoAnalyze);
363 } else {
364 DefaultInfosCapture(streamInfoCapture);
365 streamInfos.push_back(*streamInfoCapture);
366 }
367 }
368
369 rc = streamOperator_V1_1->CreateStreams_V1_1(streamInfos);
370 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
371 rc = streamOperator_V1_1->CommitStreams(OperationMode::NORMAL, abilityVec);
372 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
373 sleep(1);
374 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfos);
375 }
376
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)377 void Test::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
378 {
379 captureInfo = std::make_shared<CaptureInfo>();
380 captureInfo->streamIds_ = {streamId};
381 captureInfo->captureSetting_ = abilityVec;
382 captureInfo->enableShutterCallback_ = shutterCallback;
383 if (streamOperator_V1_2 != nullptr) {
384 rc = (CamRetCode)streamOperator_V1_2->Capture(captureId, *captureInfo, isStreaming);
385 } else if (streamOperator_V1_1 != nullptr) {
386 rc = (CamRetCode)streamOperator_V1_1->Capture(captureId, *captureInfo, isStreaming);
387 } else {
388 rc = (CamRetCode)streamOperator->Capture(captureId, *captureInfo, isStreaming);
389 }
390
391 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
392 if (rc == HDI::Camera::V1_0::NO_ERROR) {
393 CAMERA_LOGI("check Capture: Capture success, %{public}d", captureId);
394 } else {
395 std::cout << "rc = " << rc << std::endl;
396 CAMERA_LOGE("check Capture: Capture fail, rc = %{public}d", rc);
397 }
398 sleep(UT_SLEEP_TIME);
399 }
400
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)401 void Test::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
402 {
403 if (sizeof(captureIds) > 0) {
404 for (auto &captureId : captureIds) {
405 if (streamOperator_V1_2 != nullptr) {
406 rc = streamOperator_V1_2->CancelCapture(captureId);
407 } else if (streamOperator_V1_1 != nullptr) {
408 rc = streamOperator_V1_1->CancelCapture(captureId);
409 } else {
410 rc = streamOperator->CancelCapture(captureId);
411 }
412 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
413 if (rc == HDI::Camera::V1_0::NO_ERROR) {
414 CAMERA_LOGI("check Capture: CancelCapture success, %{public}d", captureId);
415 } else {
416 CAMERA_LOGE("check Capture: CancelCapture fail, rc = %{public}d, captureId = %{public}d",
417 rc, captureId);
418 }
419 }
420 }
421 if (sizeof(streamIds) > 0) {
422 if (streamOperator_V1_2 != nullptr) {
423 rc = streamOperator_V1_2->ReleaseStreams(streamIds);
424 } else if (streamOperator_V1_1 != nullptr) {
425 rc = streamOperator_V1_1->ReleaseStreams(streamIds);
426 } else {
427 rc = streamOperator->ReleaseStreams(streamIds);
428 }
429 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
430 if (rc == HDI::Camera::V1_0::NO_ERROR) {
431 CAMERA_LOGI("check Capture: ReleaseStream success");
432 } else {
433 CAMERA_LOGE("check Capture: ReleaseStreams fail, rc = %{public}d", rc);
434 }
435 }
436 if (cameraDeviceV1_2) {
437 cameraDeviceV1_2->Reset();
438 }
439 }
440
IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag,uint8_t value)441 bool Test::IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag, uint8_t value)
442 {
443 common_metadata_header_t* data = ability->get();
444 camera_metadata_item_t entry;
445 int ret = FindCameraMetadataItem(data, tag, &entry);
446 if (ret == 0 && entry.count > 0) {
447 for (int i = 0; i < entry.count; i++) {
448 if (entry.data.u8[i] == value) {
449 return true;
450 }
451 }
452 }
453 return false;
454 }
TakePhotoWithTags(std::shared_ptr<OHOS::Camera::CameraSetting> meta)455 void Test::TakePhotoWithTags(std::shared_ptr<OHOS::Camera::CameraSetting> meta)
456 {
457 streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
458 rc = cameraDeviceV1_2->GetStreamOperator_V1_1(streamOperatorCallback,
459 streamOperator_V1_1);
460 EXPECT_NE(streamOperator_V1_1, nullptr);
461 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
462
463 // preview streamInfo
464 streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
465 DefaultInfosPreview(streamInfoV1_1);
466 streamInfosV1_1.push_back(*streamInfoV1_1);
467
468 // capture streamInfo
469 streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
470 DefaultInfosCapture(streamInfoV1_1);
471 streamInfosV1_1.push_back(*streamInfoV1_1);
472
473 // create and commitstreams
474 rc = streamOperator_V1_1->CreateStreams_V1_1(streamInfosV1_1);
475 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
476 rc = streamOperator_V1_1->CommitStreams_V1_1(
477 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::PORTRAIT),
478 abilityVec);
479 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, rc);
480 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfosV1_1);
481 StartCapture(streamIdPreview, captureIdPreview, false, true);
482 StartCapture(streamIdCapture, captureIdCapture, false, true);
483 captureIds = {captureIdPreview, captureIdCapture};
484 streamIds = {streamIdPreview, streamIdCapture};
485 StopStream(captureIds, streamIds);
486 }
487
CalculateFps(int64_t timestamp,int32_t streamId)488 void Test::StreamConsumer::CalculateFps(int64_t timestamp, int32_t streamId)
489 {
490 if (isFirstCalculateFps_) {
491 if ((timestamp - intervalTimestamp_) >= interval_) {
492 int64_t timeInterval = timestamp - intervalTimestamp_;
493 if (timeInterval != 0) {
494 float fps = (int64_t)(100000000000 * timestampCount_ / timeInterval) / 100.0;
495 CAMERA_LOGI("Calculate FPS success, streamId: %{public}d, Fps:%{public}f", streamId, fps);
496 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
497 } else {
498 CAMERA_LOGE("Calculate FPS error timeInerval is 0");
499 }
500 }
501 } else {
502 intervalTimestamp_ = timestamp;
503 isFirstCalculateFps_ = true;
504 }
505 if ((timestamp - intervalTimestamp_) >= ONESECOND_OF_MICROSECOND_UNIT * UT_SECOND_TIMES) {
506 intervalTimestamp_ = timestamp;
507 timestampCount_ = 0;
508 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
509 }
510 timestampCount_++;
511 }
512
GetTimeStamp(int64_t * g_timestamp,uint32_t lenght,int64_t timestamp,int32_t gotSize)513 void Test::StreamConsumer::GetTimeStamp(int64_t *g_timestamp, uint32_t lenght, int64_t timestamp, int32_t gotSize)
514 {
515 if (gotSize != UT_PREVIEW_SIZE) {
516 if (g_timestamp[0] == 0) {
517 g_timestamp[0] = timestamp;
518 } else {
519 g_timestamp[1] = timestamp;
520 }
521 }
522 }
523
CreateProducer(std::function<void (void *,uint32_t)> callback)524 OHOS::sptr<OHOS::IBufferProducer> Test::StreamConsumer::CreateProducer(std::function<void(void*, uint32_t)> callback)
525 {
526 consumer_ = OHOS::IConsumerSurface::Create();
527 if (consumer_ == nullptr) {
528 return nullptr;
529 }
530 sptr<IBufferConsumerListener> listener = new TestBufferConsumerListener();
531 consumer_->RegisterConsumerListener(listener);
532 auto producer = consumer_->GetProducer();
533 if (producer == nullptr) {
534 return nullptr;
535 }
536
537 callback_ = callback;
538 consumerThread_ = new std::thread([this, listener] {
539 int32_t flushFence = 0;
540 int64_t timestamp = 0;
541 OHOS::Rect damage;
542 TestBufferConsumerListener* checker = static_cast<TestBufferConsumerListener*>(listener.GetRefPtr());
543 while (running_ == true) {
544 OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr;
545 if (checker->checkBufferAvailable()) {
546 consumer_->AcquireBuffer(buffer, flushFence, timestamp, damage);
547 if (buffer != nullptr) {
548 void* addr = buffer->GetVirAddr();
549 uint32_t size = buffer->GetSize();
550
551 int32_t gotSize = 0;
552 int32_t isKey = 0;
553 int32_t streamId = 0;
554 int32_t captureId = 0;
555 buffer->GetExtraData()->ExtraGet(OHOS::Camera::dataSize, gotSize);
556 buffer->GetExtraData()->ExtraGet(OHOS::Camera::isKeyFrame, isKey);
557 buffer->GetExtraData()->ExtraGet(OHOS::Camera::timeStamp, timestamp);
558 buffer->GetExtraData()->ExtraGet(OHOS::Camera::streamId, streamId);
559 buffer->GetExtraData()->ExtraGet(OHOS::Camera::captureId, captureId);
560 GetTimeStamp(g_timestamp, sizeof(g_timestamp) / sizeof(g_timestamp[0]), timestamp, gotSize);
561 if (gotSize) {
562 CalculateFps(timestamp, streamId);
563 callback_(addr, gotSize);
564 } else {
565 callback_(addr, size);
566 }
567
568 consumer_->ReleaseBuffer(buffer, -1);
569 shotCount_--;
570 if (shotCount_ == 0) {
571 std::unique_lock<std::mutex> l(l_);
572 cv_.notify_one();
573 }
574 }
575 }
576 if (running_ == false) {
577 break;
578 }
579 usleep(1);
580 }
581 });
582
583 return producer;
584 }
585
CreateProducerSeq(std::function<void (void *,uint32_t)> callback)586 OHOS::sptr<BufferProducerSequenceable> Test::StreamConsumer::CreateProducerSeq(
587 std::function<void(void*, uint32_t)> callback)
588 {
589 OHOS::sptr<OHOS::IBufferProducer> producer = CreateProducer(callback);
590 if (producer == nullptr) {
591 return nullptr;
592 }
593
594 return new BufferProducerSequenceable(producer);
595 }
596
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)597 int32_t Test::TestStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
598 {
599 for (auto it : streamId) {
600 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
601 }
602 return HDI::Camera::V1_0::NO_ERROR;
603 }
604
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)605 int32_t Test::TestStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo> &infos)
606 {
607 for (auto it : infos) {
608 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
609 it.frameCount_);
610 }
611 return HDI::Camera::V1_0::NO_ERROR;
612 }
613
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)614 int32_t Test::TestStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo> &infos)
615 {
616 for (auto it : infos) {
617 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
618 it.error_);
619 }
620 return HDI::Camera::V1_0::NO_ERROR;
621 }
622
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)623 int32_t Test::TestStreamOperatorCallback::OnFrameShutter(int32_t captureId,
624 const std::vector<int32_t> &streamIds, uint64_t timestamp)
625 {
626 (void)timestamp;
627 for (auto it : streamIds) {
628 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
629 }
630 return HDI::Camera::V1_0::NO_ERROR;
631 }
632
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)633 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
634 {
635 for (auto it : streamId) {
636 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
637 }
638 return HDI::Camera::V1_0::NO_ERROR;
639 }
640
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)641 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureEnded(int32_t captureId,
642 const std::vector<CaptureEndedInfo> &infos)
643 {
644 for (auto it : infos) {
645 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
646 it.frameCount_);
647 }
648 return HDI::Camera::V1_0::NO_ERROR;
649 }
650
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)651 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureError(int32_t captureId,
652 const std::vector<CaptureErrorInfo> &infos)
653 {
654 for (auto it : infos) {
655 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
656 it.error_);
657 }
658 return HDI::Camera::V1_0::NO_ERROR;
659 }
660
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)661 int32_t Test::TestStreamOperatorCallbackV1_2::OnFrameShutter(int32_t captureId,
662 const std::vector<int32_t> &streamIds, uint64_t timestamp)
663 {
664 (void)timestamp;
665 for (auto it : streamIds) {
666 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
667 }
668 return HDI::Camera::V1_0::NO_ERROR;
669 }
670
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)671 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted_V1_2(int32_t captureId,
672 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
673 {
674 for (auto it : infos) {
675 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
676 }
677 return HDI::Camera::V1_0::NO_ERROR;
678 }
679
OnError(ErrorType type,int32_t errorMsg)680 int32_t Test::DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg)
681 {
682 CAMERA_LOGE("type: %{public}d, errorMsg: %{public}d", type, errorMsg);
683 return HDI::Camera::V1_0::NO_ERROR;
684 }
685
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)686 int32_t Test::DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t> &result)
687 {
688 MetadataUtils::ConvertVecToMetadata(result, resultMeta);
689 if (Test::resultCallback_) {
690 Test::resultCallback_(timestamp, resultMeta);
691 }
692 return HDI::Camera::V1_0::NO_ERROR;
693 }
694
OnCameraStatus(const std::string & cameraId,CameraStatus status)695 int32_t Test::TestCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
696 {
697 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
698 return HDI::Camera::V1_0::NO_ERROR;
699 }
700
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)701 int32_t Test::TestCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
702 {
703 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
704 return HDI::Camera::V1_0::NO_ERROR;
705 }
706
OnCameraEvent(const std::string & cameraId,CameraEvent event)707 int32_t Test::TestCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
708 {
709 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
710 return HDI::Camera::V1_0::NO_ERROR;
711 }
712
OnCameraStatus(const std::string & cameraId,CameraStatus status)713 int32_t Test::TestCameraHostCallbackV1_2::OnCameraStatus(const std::string& cameraId, CameraStatus status)
714 {
715 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
716 return HDI::Camera::V1_0::NO_ERROR;
717 }
718
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)719 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
720 {
721 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
722 return HDI::Camera::V1_0::NO_ERROR;
723 }
724
OnCameraEvent(const std::string & cameraId,CameraEvent event)725 int32_t Test::TestCameraHostCallbackV1_2::OnCameraEvent(const std::string& cameraId, CameraEvent event)
726 {
727 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
728 return HDI::Camera::V1_0::NO_ERROR;
729 }
730
OnFlashlightStatus_V1_2(FlashlightStatus status)731 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus_V1_2(FlashlightStatus status)
732 {
733 CAMERA_LOGE("status: %{public}d", status);
734 Test::statusCallback = status;
735 return HDI::Camera::V1_0::NO_ERROR;
736 }
737
OnProcessDone(const std::string & imageId,const OHOS::HDI::Camera::V1_2::ImageBufferInfo & buffer)738 int32_t Test::TestImageProcessCallback::OnProcessDone(const std::string& imageId,
739 const OHOS::HDI::Camera::V1_2::ImageBufferInfo& buffer)
740 {
741 CAMERA_LOGI("imageId: %{public}s", imageId.c_str());
742 coutProcessDone_++;
743 curImageId_ = imageId;
744 curImageBufferInfo_ = buffer;
745 isDone = true;
746 return 0;
747 }
748
OnStatusChanged(OHOS::HDI::Camera::V1_2::SessionStatus status)749 int32_t Test::TestImageProcessCallback::OnStatusChanged(OHOS::HDI::Camera::V1_2::SessionStatus status)
750 {
751 CAMERA_LOGI("status: %{public}d", status);
752 curStatus_ = status;
753 coutStatusChanged_++;
754 return 0;
755 }
756
OnError(const std::string & imageId,OHOS::HDI::Camera::V1_2::ErrorCode errorCode)757 int32_t Test::TestImageProcessCallback::OnError(const std::string& imageId,
758 OHOS::HDI::Camera::V1_2::ErrorCode errorCode)
759 {
760 CAMERA_LOGI("imageId: %{public}s, errorCode: %{public}d", imageId.c_str(), errorCode);
761 curImageId_ = imageId;
762 curErrorCode_ = errorCode;
763 countError_++;
764 return 0;
765 }
766 } // OHOS::Camera