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