1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dcamera_hdf_demo.h"
17 #include "distributed_hardware_log.h"
18 #include "metadata_utils.h"
19 #include <gtest/gtest.h>
20
21 namespace OHOS {
22 namespace DistributedHardware {
DcameraHdfDemo()23 DcameraHdfDemo::DcameraHdfDemo() {}
~DcameraHdfDemo()24 DcameraHdfDemo::~DcameraHdfDemo() {}
25
26 std::vector<int32_t> results_list_;
27 const int32_t METER_POINT_X = 305;
28 const int32_t METER_POINT_Y = 205;
29 const int32_t AF_REGIONS_X = 400;
30 const int32_t AF_REGIONS_Y = 200;
31 const int32_t FPS_RANGE = 30;
32 constexpr uint32_t CAMERA_PREVIEW_WIDTH = 640;
33 constexpr uint32_t CAMERA_PREVIEW_HEIGHT = 480;
34 constexpr uint32_t CAMERA_CAPTURE_WIDTH = 1280;
35 constexpr uint32_t CAMERA_CAPTURE_HEIGHT = 960;
36 constexpr uint32_t CAMERA_VIDEO_WIDTH = 1280;
37 constexpr uint32_t CAMERA_VIDEO_HEIGHT = 960;
38
SetStreamInfo(StreamInfo & streamInfo,const std::shared_ptr<StreamCustomer> & streamCustomer,const int streamId,const StreamIntent intent)39 void DcameraHdfDemo::SetStreamInfo(StreamInfo& streamInfo,
40 const std::shared_ptr<StreamCustomer> &streamCustomer,
41 const int streamId, const StreamIntent intent)
42 {
43 constexpr uint32_t dataspace = 8;
44 constexpr uint32_t tunneledMode = 5;
45 sptr<OHOS::IBufferProducer> producer;
46
47 if (intent == OHOS::HDI::Camera::V1_0::PREVIEW) {
48 constexpr uint32_t width = CAMERA_PREVIEW_WIDTH;
49 constexpr uint32_t height = CAMERA_PREVIEW_HEIGHT;
50 streamInfo.width_ = width;
51 streamInfo.height_ = height;
52 producer = streamCustomer->CreateProducer(CAPTURE_PREVIEW, nullptr);
53 } else if (intent == OHOS::HDI::Camera::V1_0::STILL_CAPTURE) {
54 constexpr uint32_t width = CAMERA_CAPTURE_WIDTH;
55 constexpr uint32_t height = CAMERA_CAPTURE_HEIGHT;
56 streamInfo.width_ = width;
57 streamInfo.height_ = height;
58 streamInfo.encodeType_ = CAMERA_CAPTURE_ENCODE_TYPE;
59 producer = streamCustomer->CreateProducer(CAPTURE_SNAPSHOT, [this](void* addr, const uint32_t size) {
60 StoreImage((char*)addr, size);
61 });
62 } else {
63 constexpr uint32_t width = CAMERA_VIDEO_WIDTH;
64 constexpr uint32_t height = CAMERA_VIDEO_HEIGHT;
65 streamInfo.width_ = width;
66 streamInfo.height_ = height;
67 streamInfo.encodeType_ = CAMERA_VIDEO_ENCODE_TYPE;
68 OpenVideoFile();
69 producer = streamCustomer->CreateProducer(CAPTURE_VIDEO, [this](void* addr, const uint32_t size) {
70 StoreVideo((char*)addr, size);
71 });
72 }
73
74 streamInfo.streamId_ = streamId;
75 streamInfo.format_ = CAMERA_FORMAT;
76 streamInfo.dataspace_ = dataspace;
77 streamInfo.intent_ = intent;
78 streamInfo.tunneledMode_ = tunneledMode;
79
80 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
81 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
82 }
83
GetStreamOpt()84 void DcameraHdfDemo::GetStreamOpt()
85 {
86 int rc = 0;
87
88 if (streamOperator_ == nullptr) {
89 const sptr<IStreamOperatorCallback> streamOperatorCallback(new DemoStreamOperatorCallback());
90 rc = demoCameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
91 if (rc != HDI::Camera::V1_0::NO_ERROR) {
92 DHLOGI("demo test: GetStreamOpt GetStreamOperator fail");
93 streamOperator_ = nullptr;
94 }
95 }
96 }
97
CaptureSet(std::vector<uint8_t> & setNum)98 void DcameraHdfDemo::CaptureSet(std::vector<uint8_t> &setNum)
99 {
100 constexpr double latitude = 27.987500; // dummy data: Qomolangma latitde
101 constexpr double longitude = 86.927500; // dummy data: Qomolangma longituude
102 constexpr double altitude = 8848.86; // dummy data: Qomolangma altitude
103 constexpr size_t entryCapacity = 100;
104 constexpr size_t dataCapacity = 2000;
105 captureSetting_ = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
106 captureQuality_ = OHOS_CAMERA_JPEG_LEVEL_HIGH;
107 captureOrientation_ = OHOS_CAMERA_JPEG_ROTATION_270;
108 mirrorSwitch_ = OHOS_CAMERA_MIRROR_ON;
109 gps_.push_back(latitude);
110 gps_.push_back(longitude);
111 gps_.push_back(altitude);
112 captureSetting_->addEntry(OHOS_JPEG_QUALITY, static_cast<void*>(&captureQuality_),
113 sizeof(captureQuality_));
114 captureSetting_->addEntry(OHOS_JPEG_ORIENTATION, static_cast<void*>(&captureOrientation_),
115 sizeof(captureOrientation_));
116 captureSetting_->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, static_cast<void*>(&mirrorSwitch_),
117 sizeof(mirrorSwitch_));
118 captureSetting_->addEntry(OHOS_JPEG_GPS_COORDINATES, gps_.data(), gps_.size());
119
120 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting_, setNum);
121 }
122
CaptureON(const int streamId,const int captureId,CaptureMode mode)123 RetCode DcameraHdfDemo::CaptureON(const int streamId, const int captureId, CaptureMode mode)
124 {
125 DHLOGI("demo test: CaptureON enter streamId == %{public}d and captureId == %{public}d and mode == %{public}d",
126 streamId, captureId, mode);
127 std::lock_guard<std::mutex> l(metaDatalock_);
128 std::vector<uint8_t> setting;
129 bool iscapture = true;
130
131 if (mode == CAPTURE_SNAPSHOT) {
132 CaptureSet(setting);
133 } else {
134 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting_, setting);
135 }
136
137 captureInfo_.streamIds_ = {streamId};
138 if (mode == CAPTURE_SNAPSHOT) {
139 captureInfo_.captureSetting_ = setting;
140 iscapture = false;
141 } else {
142 captureInfo_.captureSetting_ = cameraAbility_;
143 iscapture = true;
144 }
145 captureInfo_.enableShutterCallback_ = false;
146 int rc = streamOperator_->Capture(captureId, captureInfo_, iscapture);
147 if (rc != HDI::Camera::V1_0::NO_ERROR) {
148 DHLOGI("demo test: CaptureStart Capture error");
149 streamOperator_->ReleaseStreams(captureInfo_.streamIds_);
150 return RC_ERROR;
151 }
152
153 DHLOGI("demo test: CaptureON exit");
154 return RC_OK;
155 }
156
CaptureOff(const int captureId,const CaptureMode mode)157 RetCode DcameraHdfDemo::CaptureOff(const int captureId, const CaptureMode mode)
158 {
159 int rc = 0;
160 DHLOGI("demo test: CaptureOff enter mode == %{public}d", mode);
161
162 if (streamOperator_ == nullptr) {
163 DHLOGI("demo test: CaptureOff streamOperator_ is nullptr");
164 return RC_ERROR;
165 }
166
167 if (mode == CAPTURE_PREVIEW) {
168 rc = streamOperator_->CancelCapture(captureId);
169 } else if (mode == CAPTURE_SNAPSHOT) {
170 rc = streamOperator_->CancelCapture(captureId);
171 } else if (mode == CAPTURE_VIDEO) {
172 rc = streamOperator_->CancelCapture(captureId);
173 close(videoFd_);
174 videoFd_ = -1;
175 }
176
177 if (rc != HDI::Camera::V1_0::NO_ERROR) {
178 DHLOGI("demo test: CaptureOff CancelCapture error mode %{public}d rc == %{public}d", mode, rc);
179 return RC_ERROR;
180 }
181 DHLOGI("demo test: CaptureOff exit");
182 return RC_OK;
183 }
184
CreateStreamInfo(const int streamId,std::shared_ptr<StreamCustomer> & streamCustomer,StreamIntent intent)185 RetCode DcameraHdfDemo::CreateStreamInfo(const int streamId, std::shared_ptr<StreamCustomer> &streamCustomer,
186 StreamIntent intent)
187 {
188 DHLOGI("demo test: CreateStream enter");
189 GetStreamOpt();
190 if (streamOperator_ == nullptr) {
191 DHLOGI("demo test: CreateStream GetStreamOpt() is nullptr");
192 return RC_ERROR;
193 }
194
195 StreamInfo streamInfo = {0};
196 SetStreamInfo(streamInfo, streamCustomer, streamId, intent);
197 if (streamInfo.bufferQueue_->producer_ == nullptr) {
198 DHLOGI("demo test: CreateStream CreateProducer(); is nullptr");
199 return RC_ERROR;
200 }
201 streamInfos_.push_back(streamInfo);
202 streamIds_.push_back(streamId);
203 return RC_OK;
204 }
205
CreateStream()206 RetCode DcameraHdfDemo::CreateStream()
207 {
208 int rc = 0;
209 DHLOGI("demo test: CreateStreams start");
210 rc = streamOperator_->CreateStreams(streamInfos_);
211 if (rc != HDI::Camera::V1_0::NO_ERROR) {
212 DHLOGI("demo test: CreateStream CreateStreams error");
213 return RC_ERROR;
214 }
215 DHLOGI("demo test: CommitStreams start");
216 rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
217 if (rc != HDI::Camera::V1_0::NO_ERROR) {
218 DHLOGI("demo test: CreateStream CommitStreams error");
219 streamOperator_->ReleaseStreams(streamIds_);
220 return RC_ERROR;
221 }
222
223 DHLOGI("demo test: CreateStream exit");
224 return RC_OK;
225 }
226
InitCameraDevice()227 RetCode DcameraHdfDemo::InitCameraDevice()
228 {
229 int rc = 0;
230 DHLOGI("demo test: InitCameraDevice enter");
231
232 if (demoCameraHost_ == nullptr) {
233 DHLOGI("demo test: InitCameraDevice demoCameraHost_ == nullptr");
234 return RC_ERROR;
235 }
236
237 (void)demoCameraHost_->GetCameraIds(cameraIds_);
238 if (cameraIds_.empty()) {
239 return RC_ERROR;
240 }
241
242 const std::string cameraId = cameraIds_.front();
243 demoCameraHost_->GetCameraAbility(cameraId, cameraAbility_);
244 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(cameraAbility_, ability_);
245
246 GetFaceDetectMode(ability_);
247 GetFocalLength(ability_);
248 GetAvailableFocusModes(ability_);
249 GetAvailableExposureModes(ability_);
250 GetExposureCompensationRange(ability_);
251 GetExposureCompensationSteps(ability_);
252 GetAvailableMeterModes(ability_);
253 GetAvailableFlashModes(ability_);
254 GetMirrorSupported(ability_);
255 GetStreamBasicConfigurations(ability_);
256 GetFpsRange(ability_);
257 GetCameraPosition(ability_);
258 GetCameraType(ability_);
259 GetCameraConnectionType(ability_);
260 GetFaceDetectMaxNum(ability_);
261
262 sptr<DemoCameraDeviceCallback> callback(new DemoCameraDeviceCallback());
263 rc = demoCameraHost_->OpenCamera(cameraIds_.front(), callback, demoCameraDevice_);
264 if (rc != HDI::Camera::V1_0::NO_ERROR || demoCameraDevice_ == nullptr) {
265 DHLOGI("demo test: InitCameraDevice OpenCamera failed");
266 return RC_ERROR;
267 }
268
269 DHLOGI("demo test: InitCameraDevice exit");
270 return RC_OK;
271 }
272
ReleaseCameraDevice()273 void DcameraHdfDemo::ReleaseCameraDevice()
274 {
275 if (demoCameraDevice_ != nullptr) {
276 DHLOGI("demo test: ReleaseCameraDevice close Device");
277 demoCameraDevice_->Close();
278 demoCameraDevice_ = nullptr;
279 }
280 }
281
InitSensors()282 void DcameraHdfDemo::InitSensors()
283 {
284 int rc = -1;
285 DHLOGI("demo test: InitSensors enter");
286 constexpr const char *demoServiceName = "distributed_camera_service";
287 if (demoCameraHost_ == nullptr) {
288 demoCameraHost_ = ICameraHost::Get(demoServiceName, false);
289 if (demoCameraHost_ == nullptr) {
290 DHLOGI("demo test: ICameraHost::Get error");
291 GTEST_SKIP() << "No Camera InitSensors Available" << std::endl;
292 } else {
293 DHLOGI("demo test: ICameraHost::Get success");
294 }
295 }
296
297 hostCallback_ = new DemoCameraHostCallback();
298 rc = demoCameraHost_->SetCallback(hostCallback_);
299 if (rc != HDI::Camera::V1_0::NO_ERROR) {
300 DHLOGI("demo test: demoCameraHost_->SetCallback(hostCallback_) error");
301 return;
302 }
303
304 demoCameraHost_->GetCameraIds(cameraIds_);
305 if (cameraIds_.size() == 0) {
306 DHLOGI("camera device list empty");
307 GTEST_SKIP() << "No Camera Available" << std::endl;
308 return;
309 }
310 }
311
InitDemo()312 void DcameraHdfDemo::InitDemo()
313 {
314 demoCameraHost_->GetCameraIds(cameraIds_);
315 if (cameraIds_.size() == 0) {
316 DHLOGI("camera device list empty");
317 GTEST_SKIP() << "No Camera Available" << std::endl;
318 return;
319 }
320 }
321
StoreImage(const char * bufStart,const uint32_t size) const322 void DcameraHdfDemo::StoreImage(const char *bufStart, const uint32_t size) const
323 {
324 DHLOGI("demo test:StoreImage size == %{public}" PRIu32, size);
325 constexpr uint32_t pathLen = 64;
326 char path[pathLen] = {0};
327 char prefix[] = "/data/";
328
329 int imgFD = 0;
330 int ret;
331 struct timeval start = {};
332 gettimeofday(&start, nullptr);
333 if (sprintf_s(path, sizeof(path), "%spicture_%ld.jpeg", prefix, start.tv_usec) < 0) {
334 DHLOGI("sprintf_s error .....");
335 return;
336 }
337
338 imgFD = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
339 if (imgFD == -1) {
340 DHLOGI("demo test:open image file error %{public}s.....", strerror(errno));
341 return;
342 }
343
344 ret = write(imgFD, bufStart, size);
345 if (ret == -1) {
346 DHLOGI("demo test:write image file error %{public}s.....", strerror(errno));
347 }
348
349 close(imgFD);
350 DHLOGI("demo test:StoreImage save success");
351 }
352
StoreVideo(const char * bufStart,const uint32_t size) const353 void DcameraHdfDemo::StoreVideo(const char *bufStart, const uint32_t size) const
354 {
355 int ret = 0;
356
357 ret = write(videoFd_, bufStart, size);
358 if (ret == -1) {
359 DHLOGI("demo test:write video file error %{public}s.....", strerror(errno));
360 }
361 DHLOGI("demo test:StoreVideo size == %{public}" PRIu32, size);
362 }
363
OpenVideoFile()364 void DcameraHdfDemo::OpenVideoFile()
365 {
366 constexpr uint32_t pathLen = 64;
367 char path[pathLen] = {0};
368 char prefix[] = "/data/";
369 auto seconds = time(nullptr);
370 if (sprintf_s(path, sizeof(path), "%svideo%ld.h264", prefix, seconds) < 0) {
371 DHLOGI("%{public}s: sprintf failed", __func__);
372 return;
373 }
374 videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
375 if (videoFd_ < 0) {
376 DHLOGI("demo test: StartVideo open %{public}s %{public}s failed", path, strerror(errno));
377 }
378 }
379
CreateStreams(const int streamIdSecond,StreamIntent intent)380 RetCode DcameraHdfDemo::CreateStreams(const int streamIdSecond, StreamIntent intent)
381 {
382 int rc = 0;
383 std::vector<StreamInfo> streamInfos;
384 std::vector<StreamInfo>().swap(streamInfos);
385
386 DHLOGI("demo test: CreateStreams streamIdSecond = %{public}d", streamIdSecond);
387 GetStreamOpt();
388 if (streamOperator_ == nullptr) {
389 DHLOGI("demo test: CreateStreams GetStreamOpt() is nullptr");
390 return RC_ERROR;
391 }
392
393 StreamInfo previewStreamInfo = {0};
394 SetStreamInfo(previewStreamInfo, streamCustomerPreview_, STREAM_ID_PREVIEW, OHOS::HDI::Camera::V1_0::PREVIEW);
395 if (previewStreamInfo.bufferQueue_->producer_ == nullptr) {
396 DHLOGI("demo test: CreateStream CreateProducer(); is nullptr");
397 return RC_ERROR;
398 }
399 streamInfos.push_back(previewStreamInfo);
400
401 StreamInfo secondStreamInfo = {0};
402 if (streamIdSecond == STREAM_ID_CAPTURE) {
403 SetStreamInfo(secondStreamInfo, streamCustomerCapture_, STREAM_ID_CAPTURE, intent);
404 } else {
405 SetStreamInfo(secondStreamInfo, streamCustomerVideo_, STREAM_ID_VIDEO, intent);
406 }
407
408 if (secondStreamInfo.bufferQueue_->producer_ == nullptr) {
409 DHLOGI("demo test: CreateStreams CreateProducer() secondStreamInfo is nullptr");
410 return RC_ERROR;
411 }
412 streamInfos.push_back(secondStreamInfo);
413
414 rc = streamOperator_->CreateStreams(streamInfos);
415 if (rc != HDI::Camera::V1_0::NO_ERROR) {
416 DHLOGI("demo test: CreateStream CreateStreams error");
417 return RC_ERROR;
418 }
419
420 rc = streamOperator_->CommitStreams(NORMAL, cameraAbility_);
421 if (rc != HDI::Camera::V1_0::NO_ERROR) {
422 DHLOGI("demo test: CreateStream CommitStreams error");
423 std::vector<int> streamIds = {STREAM_ID_PREVIEW, streamIdSecond};
424 streamOperator_->ReleaseStreams(streamIds);
425 return RC_ERROR;
426 }
427 return RC_OK;
428 }
429
CaptureOnDualStreams(const int streamIdSecond)430 RetCode DcameraHdfDemo::CaptureOnDualStreams(const int streamIdSecond)
431 {
432 int rc = 0;
433 DHLOGI("demo test: CaptuCaptureOnDualStreamsreON enter");
434
435 CaptureInfo previewCaptureInfo;
436 previewCaptureInfo.streamIds_ = {STREAM_ID_PREVIEW};
437 previewCaptureInfo.captureSetting_ = cameraAbility_;
438 previewCaptureInfo.enableShutterCallback_ = false;
439
440 rc = streamOperator_->Capture(CAPTURE_ID_PREVIEW, previewCaptureInfo, true);
441 if (rc != HDI::Camera::V1_0::NO_ERROR) {
442 DHLOGI("demo test: CaptureOnDualStreams preview Capture error");
443 streamOperator_->ReleaseStreams(previewCaptureInfo.streamIds_);
444 return RC_ERROR;
445 }
446
447 CaptureInfo secondCaptureInfo;
448 secondCaptureInfo.streamIds_ = {streamIdSecond};
449 secondCaptureInfo.captureSetting_ = cameraAbility_;
450 previewCaptureInfo.enableShutterCallback_ = false;
451
452 if (streamIdSecond == STREAM_ID_CAPTURE) {
453 rc = streamOperator_->Capture(CAPTURE_ID_CAPTURE, secondCaptureInfo, true);
454 if (rc != HDI::Camera::V1_0::NO_ERROR) {
455 DHLOGI("demo test: CaptureOnDualStreams CAPTURE_ID_CAPTURE error");
456 streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
457 return RC_ERROR;
458 }
459 } else {
460 rc = streamOperator_->Capture(CAPTURE_ID_VIDEO, secondCaptureInfo, true);
461 if (rc != HDI::Camera::V1_0::NO_ERROR) {
462 DHLOGI("demo test: CaptureOnDualStreams CAPTURE_ID_VIDEO error");
463 streamOperator_->ReleaseStreams(secondCaptureInfo.streamIds_);
464 return RC_ERROR;
465 }
466 }
467
468 DHLOGI("demo test: CaptuCaptureOnDualStreamsreON exit");
469 return RC_OK;
470 }
471
StartDualStreams(const int streamIdSecond)472 RetCode DcameraHdfDemo::StartDualStreams(const int streamIdSecond)
473 {
474 RetCode rc = RC_OK;
475 DHLOGI("demo test: StartDualStreams enter");
476
477 if (streamCustomerPreview_ == nullptr) {
478 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
479 }
480 if (isPreviewOn_ != 0) {
481 return RC_OK;
482 }
483 isPreviewOn_ = 1;
484 if (streamIdSecond == STREAM_ID_CAPTURE) {
485 if (streamCustomerCapture_ == nullptr) {
486 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
487 }
488
489 if (isCaptureOn_ == 0) {
490 isCaptureOn_ = 1;
491 rc = CreateStreams(streamIdSecond, OHOS::HDI::Camera::V1_0::STILL_CAPTURE);
492 if (rc != RC_OK) {
493 DHLOGI("demo test:StartPreviewStream CreateStreams error");
494 return RC_ERROR;
495 }
496 }
497 } else {
498 if (streamCustomerVideo_ == nullptr) {
499 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
500 }
501
502 if (isVideoOn_ == 0) {
503 isVideoOn_ = 1;
504 rc = CreateStreams(streamIdSecond, OHOS::HDI::Camera::V1_0::VIDEO);
505 if (rc != RC_OK) {
506 DHLOGI("demo test:StartPreviewStream CreateStreams error");
507 return RC_ERROR;
508 }
509 }
510 }
511
512 DHLOGI("demo test: StartDualStreams exit");
513 return RC_OK;
514 }
515
StartCaptureStream()516 RetCode DcameraHdfDemo::StartCaptureStream()
517 {
518 RetCode rc = RC_OK;
519
520 DHLOGI("demo test: StartCaptureStream enter");
521 if (streamCustomerCapture_ == nullptr) {
522 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
523 }
524
525 if (isCaptureOn_ == 0) {
526 isCaptureOn_ = 1;
527
528 rc = CreateStreamInfo(STREAM_ID_CAPTURE, streamCustomerCapture_, OHOS::HDI::Camera::V1_0::STILL_CAPTURE);
529 if (rc != RC_OK) {
530 DHLOGI("demo test:StartCaptureStream CreateStream error");
531 return RC_ERROR;
532 }
533 }
534
535 DHLOGI("demo test: StartCaptureStream exit");
536 return RC_OK;
537 }
538
StartVideoStream()539 RetCode DcameraHdfDemo::StartVideoStream()
540 {
541 RetCode rc = RC_OK;
542 DHLOGI("demo test: StartVideoStream enter");
543 if (streamCustomerVideo_ == nullptr) {
544 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
545 }
546
547 if (isVideoOn_ == 0) {
548 isVideoOn_ = 1;
549
550 rc = CreateStreamInfo(STREAM_ID_VIDEO, streamCustomerVideo_, OHOS::HDI::Camera::V1_0::VIDEO);
551 if (rc != RC_OK) {
552 DHLOGI("demo test:StartVideoStream CreateStream error");
553 return RC_ERROR;
554 }
555 }
556
557 DHLOGI("demo test: StartVideoStream exit");
558 return RC_OK;
559 }
560
StartPreviewStream()561 RetCode DcameraHdfDemo::StartPreviewStream()
562 {
563 RetCode rc = RC_OK;
564 DHLOGI("demo test: StartPreviewStream enter");
565
566 if (streamCustomerPreview_ == nullptr) {
567 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
568 }
569
570 if (isPreviewOn_ == 0) {
571 isPreviewOn_ = 1;
572
573 rc = CreateStreamInfo(STREAM_ID_PREVIEW, streamCustomerPreview_, OHOS::HDI::Camera::V1_0::PREVIEW);
574 if (rc != RC_OK) {
575 DHLOGI("demo test:StartPreviewStream CreateStream error");
576 return RC_ERROR;
577 }
578 }
579
580 DHLOGI("demo test: StartPreviewStream exit");
581 return RC_OK;
582 }
583
ReleaseAllStream()584 RetCode DcameraHdfDemo::ReleaseAllStream()
585 {
586 std::vector<int> streamIds;
587 DHLOGI("demo test: ReleaseAllStream enter");
588
589 if (isPreviewOn_ != 1) {
590 DHLOGI("demo test: ReleaseAllStream preview is not running");
591 return RC_ERROR;
592 }
593
594 if (isCaptureOn_ == 1) {
595 DHLOGI("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_CAPTURE");
596 streamIds = {STREAM_ID_PREVIEW, STREAM_ID_CAPTURE};
597 streamOperator_->ReleaseStreams(streamIds);
598 } else {
599 DHLOGI("demo test: ReleaseAllStream STREAM_ID_PREVIEW STREAM_ID_VIDEO");
600 streamIds = {STREAM_ID_PREVIEW, STREAM_ID_VIDEO};
601 streamOperator_->ReleaseStreams(streamIds);
602 }
603
604 streamInfos_.clear();
605 streamIds_.clear();
606
607 isPreviewOn_ = 0;
608 isCaptureOn_ = 0;
609 isVideoOn_ = 0;
610
611 DHLOGI("demo test: ReleaseAllStream exit");
612 return RC_OK;
613 }
614
QuitDemo()615 void DcameraHdfDemo::QuitDemo()
616 {
617 ReleaseCameraDevice();
618 DHLOGI("demo test: QuitDemo done");
619 }
620
SetEnableResult()621 void DcameraHdfDemo::SetEnableResult()
622 {
623 DHLOGI("demo test: SetEnableResult enter");
624
625 if (cameraIds_.empty()) {
626 DHLOGI("demo test: camera device list empty");
627 return;
628 }
629 results_list_.push_back(OHOS_CONTROL_EXPOSURE_MODE);
630 results_list_.push_back(OHOS_CONTROL_FOCUS_MODE);
631 if (demoCameraDevice_ != nullptr) {
632 demoCameraDevice_->EnableResult(results_list_);
633 }
634
635 DHLOGI("demo test: SetEnableResult exit");
636 }
637
SetAwbMode(const int mode) const638 RetCode DcameraHdfDemo::SetAwbMode(const int mode) const
639 {
640 DHLOGI("demo test: SetAwbMode enter");
641
642 if (mode < 0 || mode > OHOS_CAMERA_AWB_MODE_INCANDESCENT) {
643 DHLOGI("demo test: SetAwbMode mode error");
644 return RC_ERROR;
645 }
646
647 constexpr size_t entryCapacity = 100;
648 constexpr size_t dataCapacity = 2000;
649
650 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
651 std::vector<uint8_t> result;
652
653 const uint8_t awbMode = mode;
654 metaData->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
655 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
656 if (demoCameraDevice_ != nullptr) {
657 demoCameraDevice_->UpdateSettings(result);
658 }
659
660 DHLOGI("demo test: SetAwbMode exit");
661 return RC_OK;
662 }
663
SetAeExpo()664 RetCode DcameraHdfDemo::SetAeExpo()
665 {
666 int32_t expo;
667 DHLOGI("demo test: SetAeExpo enter");
668
669 constexpr size_t entryCapacity = 100;
670 constexpr size_t dataCapacity = 2000;
671
672 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
673 std::vector<uint8_t> result;
674
675 if (aeStatus_) {
676 expo = 0xa0;
677 } else {
678 expo = 0x30;
679 }
680 aeStatus_ = !aeStatus_;
681 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
682 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
683 if (demoCameraDevice_ != nullptr) {
684 demoCameraDevice_->UpdateSettings(result);
685 }
686
687 DHLOGI("demo test: SetAeExpo exit");
688 return RC_OK;
689 }
690
SetMetadataMeter(uint8_t mode)691 RetCode DcameraHdfDemo::SetMetadataMeter(uint8_t mode)
692 {
693 DHLOGI("demo test: SetMetadata enter");
694 constexpr size_t entryCapacity = 100;
695 constexpr size_t dataCapacity = 2000;
696 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
697
698 // awb
699 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
700
701 // ae
702 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
703 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
704
705 int64_t exposureTime = 400;
706 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
707
708 int32_t aeExposureCompensation = 4;
709 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
710
711 // meter
712 std::vector<int32_t> meterPoint;
713 meterPoint.push_back(METER_POINT_X);
714 meterPoint.push_back(METER_POINT_Y);
715 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
716
717 uint8_t meterMode = mode;
718 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
719
720 // flash
721 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
722 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
723
724 // mirror
725 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
726 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
727
728 // fps
729 std::vector<int32_t> fpsRange;
730 fpsRange.push_back(FPS_RANGE);
731 fpsRange.push_back(FPS_RANGE);
732 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
733
734 // jpeg
735 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
736 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
737
738 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
739 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
740
741 // af
742 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
743 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
744
745 std::vector<int32_t> afRegions;
746 afRegions.push_back(AF_REGIONS_X);
747 afRegions.push_back(AF_REGIONS_Y);
748 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
749
750 // face
751 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
752 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
753
754 std::vector<uint8_t> result;
755 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
756 if (demoCameraDevice_ != nullptr) {
757 demoCameraDevice_->UpdateSettings(result);
758 }
759
760 DHLOGI("demo test: SetMetadata exit");
761 return RC_OK;
762 }
763
SetMetadataAe(uint8_t mode)764 RetCode DcameraHdfDemo::SetMetadataAe(uint8_t mode)
765 {
766 DHLOGI("demo test: SetMetadata enter");
767 constexpr size_t entryCapacity = 100;
768 constexpr size_t dataCapacity = 2000;
769 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
770
771 // awb
772 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
773
774 // ae
775 uint8_t aeMode = mode;
776 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
777
778 int64_t exposureTime = 400;
779 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
780
781 int32_t aeExposureCompensation = 4;
782 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
783
784 // meter
785 std::vector<int32_t> meterPoint;
786 meterPoint.push_back(METER_POINT_X);
787 meterPoint.push_back(METER_POINT_Y);
788 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
789
790 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
791 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
792
793 // flash
794 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
795 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
796
797 // mirror
798 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
799 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
800
801 // fps
802 std::vector<int32_t> fpsRange;
803 fpsRange.push_back(FPS_RANGE);
804 fpsRange.push_back(FPS_RANGE);
805 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
806
807 // jpeg
808 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
809 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
810
811 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
812 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
813
814 // af
815 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
816 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
817
818 std::vector<int32_t> afRegions;
819 afRegions.push_back(AF_REGIONS_X);
820 afRegions.push_back(AF_REGIONS_Y);
821 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
822
823 // face
824 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
825 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
826
827 std::vector<uint8_t> result;
828 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
829 if (demoCameraDevice_ != nullptr) {
830 demoCameraDevice_->UpdateSettings(result);
831 }
832
833 DHLOGI("demo test: SetMetadata exit");
834 return RC_OK;
835 }
836
SetMetadataFlash(uint8_t mode)837 RetCode DcameraHdfDemo::SetMetadataFlash(uint8_t mode)
838 {
839 DHLOGI("demo test: SetMetadata enter");
840 constexpr size_t entryCapacity = 100;
841 constexpr size_t dataCapacity = 2000;
842 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
843
844 // awb
845 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
846
847 // ae
848 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
849 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
850
851 int64_t exposureTime = 400;
852 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
853
854 int32_t aeExposureCompensation = 4;
855 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
856
857 // meter
858 std::vector<int32_t> meterPoint;
859 meterPoint.push_back(METER_POINT_X);
860 meterPoint.push_back(METER_POINT_Y);
861 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
862
863 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
864 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
865
866 // flash
867 uint8_t flashMode = mode;
868 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
869
870 // mirror
871 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
872 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
873
874 // fps
875 std::vector<int32_t> fpsRange;
876 fpsRange.push_back(FPS_RANGE);
877 fpsRange.push_back(FPS_RANGE);
878 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
879
880 // jpeg
881 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
882 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
883
884 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
885 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
886
887 // af
888 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
889 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
890
891 std::vector<int32_t> afRegions;
892 afRegions.push_back(AF_REGIONS_X);
893 afRegions.push_back(AF_REGIONS_Y);
894 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
895
896 // face
897 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
898 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
899
900 std::vector<uint8_t> result;
901 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
902 if (demoCameraDevice_ != nullptr) {
903 demoCameraDevice_->UpdateSettings(result);
904 }
905
906 DHLOGI("demo test: SetMetadata exit");
907 return RC_OK;
908 }
909
SetMetadataMirror(uint8_t mode)910 RetCode DcameraHdfDemo::SetMetadataMirror(uint8_t mode)
911 {
912 DHLOGI("demo test: SetMetadata enter");
913 constexpr size_t entryCapacity = 100;
914 constexpr size_t dataCapacity = 2000;
915 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
916
917 // awb
918 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
919
920 // ae
921 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
922 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
923
924 int64_t exposureTime = 400;
925 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
926
927 int32_t aeExposureCompensation = 4;
928 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
929
930 // meter
931 std::vector<int32_t> meterPoint;
932 meterPoint.push_back(METER_POINT_X);
933 meterPoint.push_back(METER_POINT_Y);
934 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
935
936 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
937 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
938
939 // flash
940 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
941 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
942
943 // mirror
944 uint8_t mirror = mode;
945 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
946
947 // fps
948 std::vector<int32_t> fpsRange;
949 fpsRange.push_back(FPS_RANGE);
950 fpsRange.push_back(FPS_RANGE);
951 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
952
953 // jpeg
954 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
955 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
956
957 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
958 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
959
960 // af
961 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
962 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
963
964 std::vector<int32_t> afRegions;
965 afRegions.push_back(AF_REGIONS_X);
966 afRegions.push_back(AF_REGIONS_Y);
967 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
968
969 // face
970 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
971 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
972
973 std::vector<uint8_t> result;
974 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
975 if (demoCameraDevice_ != nullptr) {
976 demoCameraDevice_->UpdateSettings(result);
977 }
978
979 DHLOGI("demo test: SetMetadata exit");
980 return RC_OK;
981 }
982
SetMetadataJpeg(uint8_t mode)983 RetCode DcameraHdfDemo::SetMetadataJpeg(uint8_t mode)
984 {
985 DHLOGI("demo test: SetMetadata enter");
986 constexpr size_t entryCapacity = 100;
987 constexpr size_t dataCapacity = 2000;
988 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
989
990 // awb
991 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
992
993 // ae
994 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
995 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
996
997 int64_t exposureTime = 400;
998 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
999
1000 int32_t aeExposureCompensation = 4;
1001 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1002
1003 // meter
1004 std::vector<int32_t> meterPoint;
1005 meterPoint.push_back(METER_POINT_X);
1006 meterPoint.push_back(METER_POINT_Y);
1007 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1008
1009 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1010 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1011
1012 // flash
1013 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1014 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1015
1016 // mirror
1017 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1018 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1019
1020 // fps
1021 std::vector<int32_t> fpsRange;
1022 fpsRange.push_back(FPS_RANGE);
1023 fpsRange.push_back(FPS_RANGE);
1024 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1025
1026 // jpeg
1027 int32_t orientation = mode;
1028 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1029
1030 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1031 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1032
1033 // af
1034 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1035 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1036
1037 std::vector<int32_t> afRegions;
1038 afRegions.push_back(AF_REGIONS_X);
1039 afRegions.push_back(AF_REGIONS_Y);
1040 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1041
1042 // face
1043 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1044 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1045
1046 std::vector<uint8_t> result;
1047 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1048 if (demoCameraDevice_ != nullptr) {
1049 demoCameraDevice_->UpdateSettings(result);
1050 }
1051
1052 DHLOGI("demo test: SetMetadata exit");
1053 return RC_OK;
1054 }
1055
SetMetadataAf(uint8_t mode)1056 RetCode DcameraHdfDemo::SetMetadataAf(uint8_t mode)
1057 {
1058 DHLOGI("demo test: SetMetadata enter");
1059 constexpr size_t entryCapacity = 100;
1060 constexpr size_t dataCapacity = 2000;
1061 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1062
1063 // awb
1064 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1065
1066 // ae
1067 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1068 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1069
1070 int64_t exposureTime = 400;
1071 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1072
1073 int32_t aeExposureCompensation = 4;
1074 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1075
1076 // meter
1077 std::vector<int32_t> meterPoint;
1078 meterPoint.push_back(METER_POINT_X);
1079 meterPoint.push_back(METER_POINT_Y);
1080 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1081
1082 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1083 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1084
1085 // flash
1086 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1087 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1088
1089 // mirror
1090 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1091 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1092
1093 // fps
1094 std::vector<int32_t> fpsRange;
1095 fpsRange.push_back(FPS_RANGE);
1096 fpsRange.push_back(FPS_RANGE);
1097 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1098
1099 // jpeg
1100 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1101 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1102
1103 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1104 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1105
1106 // af
1107 uint8_t afMode = mode;
1108 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1109
1110 std::vector<int32_t> afRegions;
1111 afRegions.push_back(AF_REGIONS_X);
1112 afRegions.push_back(AF_REGIONS_Y);
1113 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1114
1115 // face
1116 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1117 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1118
1119 std::vector<uint8_t> result;
1120 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1121 if (demoCameraDevice_ != nullptr) {
1122 demoCameraDevice_->UpdateSettings(result);
1123 }
1124
1125 DHLOGI("demo test: SetMetadata exit");
1126 return RC_OK;
1127 }
1128
SetMetadataFace(uint8_t mode)1129 RetCode DcameraHdfDemo::SetMetadataFace(uint8_t mode)
1130 {
1131 DHLOGI("demo test: SetMetadata enter");
1132 constexpr size_t entryCapacity = 100;
1133 constexpr size_t dataCapacity = 2000;
1134 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1135
1136 // awb
1137 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1138
1139 // ae
1140 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1141 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1142
1143 int64_t exposureTime = 400;
1144 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1145
1146 int32_t aeExposureCompensation = 4;
1147 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1148
1149 // meter
1150 std::vector<int32_t> meterPoint;
1151 meterPoint.push_back(METER_POINT_X);
1152 meterPoint.push_back(METER_POINT_Y);
1153 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1154
1155 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1156 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1157
1158 // flash
1159 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1160 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1161
1162 // mirror
1163 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1164 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1165
1166 // fps
1167 std::vector<int32_t> fpsRange;
1168 fpsRange.push_back(FPS_RANGE);
1169 fpsRange.push_back(FPS_RANGE);
1170 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1171
1172 // jpeg
1173 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1174 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1175
1176 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1177 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1178
1179 // af
1180 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1181 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1182
1183 std::vector<int32_t> afRegions;
1184 afRegions.push_back(AF_REGIONS_X);
1185 afRegions.push_back(AF_REGIONS_Y);
1186 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1187
1188 // face
1189 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1190 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1191
1192 std::vector<uint8_t> result;
1193 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1194 if (demoCameraDevice_ != nullptr) {
1195 demoCameraDevice_->UpdateSettings(result);
1196 }
1197
1198 DHLOGI("demo test: SetMetadata exit");
1199 return RC_OK;
1200 }
1201
SetMetadata()1202 RetCode DcameraHdfDemo::SetMetadata()
1203 {
1204 DHLOGI("demo test: SetMetadata enter");
1205 constexpr size_t entryCapacity = 100;
1206 constexpr size_t dataCapacity = 2000;
1207 std::shared_ptr<CameraSetting> metaData = std::make_shared<CameraSetting>(entryCapacity, dataCapacity);
1208
1209 // awb
1210 SetAwbMode(OHOS_CAMERA_AWB_MODE_INCANDESCENT);
1211
1212 // ae
1213 uint8_t aeMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
1214 metaData->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &aeMode, sizeof(aeMode));
1215
1216 int64_t exposureTime = 400;
1217 metaData->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &exposureTime, sizeof(exposureTime));
1218
1219 int32_t aeExposureCompensation = 4;
1220 metaData->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(aeExposureCompensation));
1221
1222 // meter
1223 std::vector<int32_t> meterPoint;
1224 meterPoint.push_back(METER_POINT_X);
1225 meterPoint.push_back(METER_POINT_Y);
1226 metaData->addEntry(OHOS_CONTROL_METER_POINT, meterPoint.data(), meterPoint.size());
1227
1228 uint8_t meterMode = OHOS_CAMERA_OVERALL_METERING;
1229 metaData->addEntry(OHOS_CONTROL_METER_MODE, &meterMode, sizeof(meterMode));
1230
1231 // flash
1232 uint8_t flashMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
1233 metaData->addEntry(OHOS_CONTROL_FLASH_MODE, &flashMode, sizeof(flashMode));
1234
1235 // mirror
1236 uint8_t mirror = OHOS_CAMERA_MIRROR_ON;
1237 metaData->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(mirror));
1238
1239 // fps
1240 std::vector<int32_t> fpsRange;
1241 fpsRange.push_back(FPS_RANGE);
1242 fpsRange.push_back(FPS_RANGE);
1243 metaData->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
1244
1245 // jpeg
1246 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_180;
1247 metaData->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(orientation));
1248
1249 uint8_t quality = OHOS_CAMERA_JPEG_LEVEL_HIGH;
1250 metaData->addEntry(OHOS_JPEG_QUALITY, &quality, sizeof(quality));
1251
1252 // af
1253 uint8_t afMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1254 metaData->addEntry(OHOS_CONTROL_FOCUS_MODE, &afMode, sizeof(afMode));
1255
1256 std::vector<int32_t> afRegions;
1257 afRegions.push_back(AF_REGIONS_X);
1258 afRegions.push_back(AF_REGIONS_Y);
1259 metaData->addEntry(OHOS_CONTROL_AF_REGIONS, afRegions.data(), afRegions.size());
1260
1261 // face
1262 uint8_t faceMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
1263 metaData->addEntry(OHOS_STATISTICS_FACE_DETECT_SWITCH, &faceMode, sizeof(faceMode));
1264
1265 std::vector<uint8_t> result;
1266 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(metaData, result);
1267 if (demoCameraDevice_ != nullptr) {
1268 demoCameraDevice_->UpdateSettings(result);
1269 }
1270
1271 DHLOGI("demo test: SetMetadata exit");
1272 return RC_OK;
1273 }
1274
FlashlightOnOff(bool onOff)1275 void DcameraHdfDemo::FlashlightOnOff(bool onOff)
1276 {
1277 DHLOGI("demo test: FlashlightOnOff enter");
1278
1279 if (demoCameraHost_ == nullptr) {
1280 DHLOGI("demo test: FlashlightOnOff demoCameraHost_ == nullptr");
1281 return;
1282 }
1283
1284 demoCameraHost_->SetFlashlight(cameraIds_.front(), onOff);
1285
1286 DHLOGI("demo test: FlashlightOnOff exit ");
1287 }
1288
StreamOffline(const int streamId)1289 RetCode DcameraHdfDemo::StreamOffline(const int streamId)
1290 {
1291 int rc = 0;
1292 constexpr size_t offlineDelayTime = 4;
1293 DHLOGI("demo test: StreamOffline enter");
1294 sptr<IStreamOperatorCallback> streamOperatorCallback(new DemoStreamOperatorCallback());
1295 sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
1296 std::vector<int> streamIds;
1297 streamIds.push_back(streamId);
1298 rc = streamOperator_->ChangeToOfflineStream(streamIds, streamOperatorCallback, offlineStreamOperator);
1299 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1300 DHLOGI("demo test: StreamOffline ChangeToOfflineStream error");
1301 return RC_ERROR;
1302 }
1303
1304 CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1305 CaptureOff(CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1306 sleep(1);
1307 ReleaseAllStream();
1308 ReleaseCameraDevice();
1309 sleep(offlineDelayTime);
1310
1311 DHLOGI("demo test: begin to release offlne stream");
1312 if (offlineStreamOperator != nullptr) {
1313 rc = offlineStreamOperator->CancelCapture(CAPTURE_ID_CAPTURE);
1314 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1315 DHLOGI("demo test: StreamOffline offlineStreamOperator->CancelCapture error");
1316 return RC_ERROR;
1317 }
1318
1319 rc = offlineStreamOperator->Release();
1320 if (rc != CamRetCode::METHOD_NOT_SUPPORTED) {
1321 DHLOGI("demo test: StreamOffline offlineStreamOperator->Release() error");
1322 return RC_ERROR;
1323 }
1324 }
1325
1326 DHLOGI("demo test: StreamOffline exit");
1327 return RC_OK;
1328 }
1329
GetFaceDetectMode(std::shared_ptr<CameraAbility> & ability)1330 RetCode DcameraHdfDemo::GetFaceDetectMode(std::shared_ptr<CameraAbility> &ability)
1331 {
1332 common_metadata_header_t* data = ability->get();
1333 uint8_t faceDetectMode;
1334 camera_metadata_item_t entry;
1335 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MODE, &entry);
1336 if (ret != 0) {
1337 DHLOGI("demo test: get OHOS_STATISTICS_FACE_DETECT_MODE error");
1338 return RC_ERROR;
1339 }
1340 faceDetectMode = *(entry.data.u8);
1341 DHLOGI("demo test: faceDetectMode %{public}" PRIu8, faceDetectMode);
1342 return RC_OK;
1343 }
1344
GetFocalLength(std::shared_ptr<CameraAbility> & ability)1345 RetCode DcameraHdfDemo::GetFocalLength(std::shared_ptr<CameraAbility> &ability)
1346 {
1347 common_metadata_header_t* data = ability->get();
1348 float focalLength = 0.0;
1349 camera_metadata_item_t entry;
1350 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1351 if (ret != 0) {
1352 DHLOGI("demo test: get OHOS_ABILITY_FOCAL_LENGTH error");
1353 return RC_ERROR;
1354 }
1355 focalLength = *(entry.data.f);
1356 DHLOGI("demo test: focalLength %{public}f", focalLength);
1357 return RC_OK;
1358 }
1359
GetAvailableFocusModes(std::shared_ptr<CameraAbility> & ability)1360 RetCode DcameraHdfDemo::GetAvailableFocusModes(std::shared_ptr<CameraAbility> &ability)
1361 {
1362 common_metadata_header_t* data = ability->get();
1363 std::vector<uint8_t> focusMode;
1364 camera_metadata_item_t entry;
1365 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1366 if (ret != 0) {
1367 DHLOGI("demo test: get OHOS_ABILITY_FOCUS_MODES error");
1368 return RC_ERROR;
1369 }
1370 uint32_t count = entry.count;
1371 DHLOGI("demo test: count %{public}" PRIu32, count);
1372
1373 for (uint32_t i = 0 ; i < count; i++) {
1374 focusMode.push_back(*(entry.data.u8 + i));
1375 }
1376
1377 for (auto it = focusMode.begin(); it != focusMode.end(); it++) {
1378 DHLOGI("demo test: focusMode : %{public}" PRIu8" ", *it);
1379 }
1380 return RC_OK;
1381 }
1382
GetAvailableExposureModes(std::shared_ptr<CameraAbility> & ability)1383 RetCode DcameraHdfDemo::GetAvailableExposureModes(std::shared_ptr<CameraAbility> &ability)
1384 {
1385 common_metadata_header_t* data = ability->get();
1386 std::vector<uint8_t> exposureMode;
1387 camera_metadata_item_t entry;
1388 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
1389 if (ret != 0) {
1390 DHLOGI("demo test: get OHOS_ABILITY_EXPOSURE_MODES error");
1391 return RC_ERROR;
1392 }
1393 uint32_t count = entry.count;
1394 DHLOGI("demo test: count %{public}" PRIu32, count);
1395
1396 for (uint32_t i = 0 ; i < count; i++) {
1397 exposureMode.push_back(*(entry.data.u8 + i));
1398 }
1399
1400 for (auto it = exposureMode.begin(); it != exposureMode.end(); it++) {
1401 DHLOGI("demo test: exposureMode : %{public}" PRIu8" ", *it);
1402 }
1403 return RC_OK;
1404 }
1405
GetExposureCompensationRange(std::shared_ptr<CameraAbility> & ability)1406 RetCode DcameraHdfDemo::GetExposureCompensationRange(std::shared_ptr<CameraAbility> &ability)
1407 {
1408 common_metadata_header_t* data = ability->get();
1409 std::vector<int32_t> exposureCompensationRange;
1410 camera_metadata_item_t entry;
1411 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_RANGE, &entry);
1412 if (ret != 0) {
1413 DHLOGI("demo test: get OHOS_ABILITY_AE_COMPENSATION_RANGE error");
1414 return RC_ERROR;
1415 }
1416
1417 uint32_t count = entry.count;
1418 DHLOGI("demo test: exposureCompensationRange count %{public}" PRIu32, count);
1419 for (uint32_t i = 0 ; i < count; i++) {
1420 exposureCompensationRange.push_back(*(entry.data.i32 + i));
1421 }
1422
1423 for (auto it = exposureCompensationRange.begin(); it != exposureCompensationRange.end(); it++) {
1424 DHLOGI("demo test: exposureCompensationRange %{public}d ", *it);
1425 }
1426
1427 return RC_OK;
1428 }
1429
GetExposureCompensationSteps(std::shared_ptr<CameraAbility> & ability)1430 RetCode DcameraHdfDemo::GetExposureCompensationSteps(std::shared_ptr<CameraAbility> &ability)
1431 {
1432 common_metadata_header_t* data = ability->get();
1433 camera_rational_t exposureCompensationSteps;
1434 camera_metadata_item_t entry;
1435 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_AE_COMPENSATION_STEP, &entry);
1436 if (ret != 0) {
1437 DHLOGI("demo test: get OHOS_ABILITY_AE_COMPENSATION_STEP error");
1438 return RC_ERROR;
1439 }
1440 exposureCompensationSteps.numerator = entry.data.r->numerator;
1441 exposureCompensationSteps.denominator = entry.data.r->denominator;
1442 DHLOGI("demo test: steps.numerator %{public}d and steps.denominator %{public}d ",
1443 exposureCompensationSteps.numerator, exposureCompensationSteps.denominator);
1444 return RC_OK;
1445 }
1446
GetAvailableMeterModes(std::shared_ptr<CameraAbility> & ability)1447 RetCode DcameraHdfDemo::GetAvailableMeterModes(std::shared_ptr<CameraAbility> &ability)
1448 {
1449 common_metadata_header_t* data = ability->get();
1450 std::vector<uint8_t> meterModes;
1451 camera_metadata_item_t entry;
1452 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
1453 if (ret != 0) {
1454 DHLOGI("demo test: get OHOS_ABILITY_METER_MODES error");
1455 return RC_ERROR;
1456 }
1457 uint32_t count = entry.count;
1458 DHLOGI("demo test: count %{public}" PRIu32, count);
1459
1460 for (uint32_t i = 0 ; i < count; i++) {
1461 meterModes.push_back(*(entry.data.u8 + i));
1462 }
1463
1464 for (auto it = meterModes.begin(); it != meterModes.end(); it++) {
1465 DHLOGI("demo test: meterModes : %{public}" PRIu8" ", *it);
1466 }
1467 return RC_OK;
1468 }
1469
GetAvailableFlashModes(std::shared_ptr<CameraAbility> & ability)1470 RetCode DcameraHdfDemo::GetAvailableFlashModes(std::shared_ptr<CameraAbility> &ability)
1471 {
1472 common_metadata_header_t* data = ability->get();
1473 std::vector<uint8_t> flashModes;
1474 camera_metadata_item_t entry;
1475 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
1476 if (ret != 0) {
1477 DHLOGI("demo test: get OHOS_ABILITY_FLASH_MODES error");
1478 return RC_ERROR;
1479 }
1480 uint32_t count = entry.count;
1481 DHLOGI("demo test: count %{public}" PRIu32, count);
1482
1483 for (uint32_t i = 0 ; i < count; i++) {
1484 flashModes.push_back(*(entry.data.u8 + i));
1485 }
1486
1487 for (auto it = flashModes.begin(); it != flashModes.end(); it++) {
1488 DHLOGI("demo test: flashModes : %{public}" PRIu8" ", *it);
1489 }
1490 return RC_OK;
1491 }
1492
GetMirrorSupported(std::shared_ptr<CameraAbility> & ability)1493 RetCode DcameraHdfDemo::GetMirrorSupported(std::shared_ptr<CameraAbility> &ability)
1494 {
1495 common_metadata_header_t* data = ability->get();
1496 uint8_t mirrorSupported;
1497 camera_metadata_item_t entry;
1498 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1499 if (ret != 0) {
1500 DHLOGI("demo test: get OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED error");
1501 return RC_ERROR;
1502 }
1503 mirrorSupported = *(entry.data.u8);
1504 DHLOGI("demo test: mirrorSupported %{public}" PRIu8, mirrorSupported);
1505 return RC_OK;
1506 }
1507
GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> & ability)1508 RetCode DcameraHdfDemo::GetStreamBasicConfigurations(std::shared_ptr<CameraAbility> &ability)
1509 {
1510 common_metadata_header_t* data = ability->get();
1511 std::vector<int32_t> streamBasicConfigurations;
1512 camera_metadata_item_t entry;
1513 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1514 if (ret != 0) {
1515 DHLOGI("demo test: get OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS error");
1516 return RC_ERROR;
1517 }
1518
1519 uint32_t count = entry.count;
1520 DHLOGI("demo test: streamBasicConfigurations count %{public}" PRIu32, count);
1521 for (uint32_t i = 0 ; i < count; i++) {
1522 streamBasicConfigurations.push_back(*(entry.data.i32 + i));
1523 }
1524
1525 for (auto it = streamBasicConfigurations.begin(); it != streamBasicConfigurations.end(); it++) {
1526 DHLOGI("demo test: streamBasicConfigurations %{public}d ", *it);
1527 }
1528
1529 return RC_OK;
1530 }
1531
GetFpsRange(std::shared_ptr<CameraAbility> & ability)1532 RetCode DcameraHdfDemo::GetFpsRange(std::shared_ptr<CameraAbility> &ability)
1533 {
1534 common_metadata_header_t* data = ability->get();
1535 std::vector<int32_t> fpsRange;
1536 camera_metadata_item_t entry;
1537 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1538 if (ret != 0) {
1539 DHLOGI("demo test: get OHOS_ABILITY_FPS_RANGES error");
1540 return RC_ERROR;
1541 }
1542
1543 uint32_t count = entry.count;
1544 DHLOGI("demo test: fpsRange count %{public}" PRIu32, count);
1545 for (uint32_t i = 0 ; i < count; i++) {
1546 fpsRange.push_back(*(entry.data.i32 + i));
1547 }
1548
1549 for (auto it = fpsRange.begin(); it != fpsRange.end(); it++) {
1550 DHLOGI("demo test: fpsRange %{public}d ", *it);
1551 }
1552
1553 return RC_OK;
1554 }
1555
GetCameraPosition(std::shared_ptr<CameraAbility> & ability)1556 RetCode DcameraHdfDemo::GetCameraPosition(std::shared_ptr<CameraAbility> &ability)
1557 {
1558 common_metadata_header_t* data = ability->get();
1559 uint8_t cameraPosition;
1560 camera_metadata_item_t entry;
1561 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1562 if (ret != 0) {
1563 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_POSITION error");
1564 return RC_ERROR;
1565 }
1566
1567 cameraPosition= *(entry.data.u8);
1568 DHLOGI("demo test: cameraPosition %{public}" PRIu8, cameraPosition);
1569 return RC_OK;
1570 }
1571
GetCameraType(std::shared_ptr<CameraAbility> & ability)1572 RetCode DcameraHdfDemo::GetCameraType(std::shared_ptr<CameraAbility> &ability)
1573 {
1574 common_metadata_header_t* data = ability->get();
1575 uint8_t cameraType;
1576 camera_metadata_item_t entry;
1577 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1578 if (ret != 0) {
1579 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_TYPE error");
1580 return RC_ERROR;
1581 }
1582
1583 cameraType= *(entry.data.u8);
1584 DHLOGI("demo test: cameraType %{public}" PRIu8, cameraType);
1585 return RC_OK;
1586 }
1587
GetCameraConnectionType(std::shared_ptr<CameraAbility> & ability)1588 RetCode DcameraHdfDemo::GetCameraConnectionType(std::shared_ptr<CameraAbility> &ability)
1589 {
1590 common_metadata_header_t* data = ability->get();
1591 uint8_t cameraConnectionType;
1592 camera_metadata_item_t entry;
1593 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1594 if (ret != 0) {
1595 DHLOGI("demo test: get OHOS_ABILITY_CAMERA_CONNECTION_TYPE error");
1596 return RC_ERROR;
1597 }
1598
1599 cameraConnectionType= *(entry.data.u8);
1600 DHLOGI("demo test: cameraConnectionType %{public}" PRIu8, cameraConnectionType);
1601 return RC_OK;
1602 }
1603
GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> & ability)1604 RetCode DcameraHdfDemo::GetFaceDetectMaxNum(std::shared_ptr<CameraAbility> &ability)
1605 {
1606 common_metadata_header_t* data = ability->get();
1607 uint8_t faceDetectMaxNum;
1608 camera_metadata_item_t entry;
1609 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MAX_NUM, &entry);
1610 if (ret != 0) {
1611 DHLOGI("demo test: get OHOS_STATISTICS_FACE_DETECT_MAX_NUM error");
1612 return RC_ERROR;
1613 }
1614 faceDetectMaxNum = *(entry.data.u8);
1615 DHLOGI("demo test: faceDetectMaxNum %{public}" PRIu8, faceDetectMaxNum);
1616 return RC_OK;
1617 }
1618
OnError(ErrorType type,int32_t errorCode)1619 int32_t DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorCode)
1620 {
1621 DHLOGI("demo test: OnError type : %{public}d, errorCode : %{public}d", type, errorCode);
1622 return RC_OK;
1623 }
1624
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)1625 int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t>& result)
1626 {
1627 DHLOGI("demo test: OnResult timestamp : %{public}" PRIu64, timestamp);
1628 std::shared_ptr<OHOS::Camera::CameraMetadata> updateSettings;
1629
1630 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(result, updateSettings);
1631 for (auto it = results_list_.cbegin(); it != results_list_.cend(); it++) {
1632 switch (*it) {
1633 case OHOS_CONTROL_FOCUS_MODE: {
1634 common_metadata_header_t* data = updateSettings->get();
1635 uint8_t focusMode;
1636 camera_metadata_item_t entry;
1637 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry);
1638 if (ret != 0) {
1639 DHLOGI("demo test: get OHOS_CONTROL_FOCUS_MODE error");
1640 return RC_ERROR;
1641 }
1642 focusMode = *(entry.data.u8);
1643 DHLOGI("demo test: focusMode %{public}" PRIu8, focusMode);
1644 break;
1645 }
1646 case OHOS_CONTROL_EXPOSURE_MODE: {
1647 common_metadata_header_t* data = updateSettings->get();
1648 uint8_t exposureMode;
1649 camera_metadata_item_t entry;
1650 int ret = OHOS::Camera::FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry);
1651 if (ret != 0) {
1652 return RC_ERROR;
1653 }
1654 exposureMode = *(entry.data.u8);
1655 DHLOGI("demo test: exposureMode %{public}" PRIu8, exposureMode);
1656 break;
1657 }
1658 default:
1659 return RC_ERROR;
1660 }
1661 }
1662
1663 return RC_OK;
1664 }
1665
OnCameraStatus(const std::string & cameraId,CameraStatus status)1666 int32_t DemoCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
1667 {
1668 DHLOGI("%{public}s, enter. cameraId = %{public}s, status = %{public}d",
1669 __func__, cameraId.c_str(), static_cast<int>(status));
1670 return RC_OK;
1671 }
1672
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)1673 int32_t DemoCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
1674 {
1675 DHLOGI("%{public}s, enter. cameraId = %{public}s, status = %{public}d",
1676 __func__, cameraId.c_str(), static_cast<int>(status));
1677 return RC_OK;
1678 }
1679
OnCameraEvent(const std::string & cameraId,CameraEvent event)1680 int32_t DemoCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
1681 {
1682 DHLOGI("%{public}s, enter. cameraId = %{public}s, event = %{public}d",
1683 __func__, cameraId.c_str(), static_cast<int>(event));
1684 return RC_OK;
1685 }
1686
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamIds)1687 int32_t DemoStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds)
1688 {
1689 DHLOGI("%{public}s, enter. captureId = %{public}d, streamIds size = %{public}zu", __func__,
1690 captureId, streamIds.size());
1691 return RC_OK;
1692 }
1693
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)1694 int32_t DemoStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos)
1695 {
1696 DHLOGI("%{public}s, enter. captureId = %{public}d, infos size = %{public}zu", __func__, captureId, infos.size());
1697 return RC_OK;
1698 }
1699
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)1700 int32_t DemoStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos)
1701 {
1702 DHLOGI("%{public}s, enter. captureId = %{public}d, infos size = %{public}zu", __func__, captureId, infos.size());
1703 return RC_OK;
1704 }
1705
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)1706 int32_t DemoStreamOperatorCallback::OnFrameShutter(int32_t captureId,
1707 const std::vector<int32_t>& streamIds, uint64_t timestamp)
1708 {
1709 DHLOGI("%{public}s, enter. captureId = %{public}d, streamIds size = %{public}zu, timestamp = %{public}" PRIu64,
1710 __func__, captureId, streamIds.size(), timestamp);
1711 return RC_OK;
1712 }
1713
PreviewOn(int mode,const std::shared_ptr<DcameraHdfDemo> & mainDemo)1714 RetCode PreviewOn(int mode, const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1715 {
1716 RetCode rc = RC_OK;
1717 DHLOGI("main test: PreviewOn enter");
1718
1719 if (mode != 0 || mainDemo == nullptr) {
1720 DHLOGI("main test: mainDemo is nullptr or mode is 0");
1721 return RC_ERROR;
1722 }
1723
1724 rc = mainDemo->StartPreviewStream();
1725 if (rc != RC_OK) {
1726 DHLOGI("main test: PreviewOn StartPreviewStream error");
1727 return RC_ERROR;
1728 }
1729 DHLOGI("main test: StartPreviewStream enter");
1730 if (mode == 0) {
1731 rc = mainDemo->StartCaptureStream();
1732 if (rc != RC_OK) {
1733 DHLOGI("main test: PreviewOn StartCaptureStream error");
1734 return RC_ERROR;
1735 }
1736 DHLOGI("main test: StartCaptureStream enter");
1737 } else {
1738 rc = mainDemo->StartVideoStream();
1739 if (rc != RC_OK) {
1740 DHLOGI("main test: PreviewOn StartVideoStream error");
1741 return RC_ERROR;
1742 }
1743 DHLOGI("main test: StartVideoStream enter");
1744 }
1745 rc = mainDemo->CreateStream();
1746 rc = mainDemo->CaptureON(STREAM_ID_PREVIEW, CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1747 if (rc != RC_OK) {
1748 DHLOGI("main test: PreviewOn mainDemo->CaptureON() preview error");
1749 return RC_ERROR;
1750 }
1751
1752 DHLOGI("main test: PreviewOn exit");
1753 return RC_OK;
1754 }
1755
PreviewOff(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1756 void PreviewOff(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1757 {
1758 DHLOGI("main test: PreviewOff enter");
1759
1760 mainDemo->CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1761 mainDemo->ReleaseAllStream();
1762
1763 DHLOGI("main test: PreviewOff exit");
1764 }
1765
FlashLightTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1766 RetCode FlashLightTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1767 {
1768 constexpr size_t delayTime = 5;
1769
1770 if (mainDemo == nullptr) {
1771 DHLOGI("main test: FlashLightTest mainDemo is nullptr");
1772 return RC_ERROR;
1773 }
1774
1775 PreviewOff(mainDemo);
1776 mainDemo->ReleaseCameraDevice();
1777 sleep(1);
1778 mainDemo->FlashlightOnOff(true);
1779 sleep(delayTime);
1780 mainDemo->FlashlightOnOff(false);
1781 mainDemo->InitCameraDevice();
1782 PreviewOn(0, mainDemo);
1783 return RC_OK;
1784 }
1785
OfflineTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1786 RetCode OfflineTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1787 {
1788 RetCode rc = RC_OK;
1789 int32_t dalayTime = 5;
1790
1791 if (mainDemo == nullptr) {
1792 DHLOGI("main test: OfflineTest mainDemo is nullptr");
1793 return RC_ERROR;
1794 }
1795
1796 PreviewOff(mainDemo);
1797
1798 mainDemo->StartDualStreams(STREAM_ID_CAPTURE);
1799 mainDemo->CaptureOnDualStreams(STREAM_ID_CAPTURE);
1800 sleep(1);
1801
1802 rc = mainDemo->StreamOffline(STREAM_ID_CAPTURE);
1803 if (rc != RC_OK) {
1804 DHLOGI("main test: mainDemo->StreamOffline error");
1805 return RC_ERROR;
1806 }
1807
1808 sleep(dalayTime);
1809 mainDemo->InitCameraDevice();
1810 rc = PreviewOn(0, mainDemo);
1811 if (rc != RC_OK) {
1812 DHLOGI("main test: PreviewOn() error");
1813 return RC_ERROR;
1814 }
1815 return RC_OK;
1816 }
1817
CaptureTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1818 RetCode CaptureTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1819 {
1820 RetCode rc = RC_OK;
1821 constexpr size_t delayTime = 5;
1822
1823 if (mainDemo == nullptr) {
1824 DHLOGI("main test: CaptureTest mainDemo is nullptr");
1825 return RC_ERROR;
1826 }
1827
1828 rc = mainDemo->CaptureON(STREAM_ID_CAPTURE, CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1829 if (rc != RC_OK) {
1830 DHLOGI("main test: mainDemo->CaptureON() capture error");
1831 return RC_ERROR;
1832 }
1833
1834 sleep(delayTime);
1835 rc = mainDemo->CaptureOff(CAPTURE_ID_CAPTURE, CAPTURE_SNAPSHOT);
1836 if (rc != RC_OK) {
1837 DHLOGI("main test: mainDemo->CaptureOff() capture error");
1838 return RC_ERROR;
1839 }
1840 DHLOGI("main test: CaptureON success");
1841 return RC_OK;
1842 }
1843
VideoTest(const std::shared_ptr<DcameraHdfDemo> & mainDemo)1844 RetCode VideoTest(const std::shared_ptr<DcameraHdfDemo>& mainDemo)
1845 {
1846 RetCode rc = RC_OK;
1847 constexpr size_t delayTime = 5;
1848
1849 if (mainDemo == nullptr) {
1850 DHLOGI("main test: VideoTest mainDemo is nullptr");
1851 return RC_ERROR;
1852 }
1853
1854 PreviewOff(mainDemo);
1855 mainDemo->StartDualStreams(STREAM_ID_VIDEO);
1856 mainDemo->CaptureOnDualStreams(STREAM_ID_VIDEO);
1857
1858 sleep(delayTime);
1859 mainDemo->CaptureOff(CAPTURE_ID_PREVIEW, CAPTURE_PREVIEW);
1860 mainDemo->CaptureOff(CAPTURE_ID_VIDEO, CAPTURE_VIDEO);
1861 mainDemo->ReleaseAllStream();
1862
1863 rc = PreviewOn(0, mainDemo);
1864 if (rc != RC_OK) {
1865 DHLOGI("main test: video PreviewOn() error please -q exit demo");
1866 return RC_ERROR;
1867 }
1868 return RC_OK;
1869 }
1870 }
1871 } // namespace OHOS::Camera
1872