1 /*
2 * Copyright (c) 2021-2022 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_client.h"
17
18 #include "anonymous_string.h"
19 #include "camera_util.h"
20 #include "camera_metadata_operator.h"
21 #include "dcamera_input_callback.h"
22 #include "dcamera_manager_callback.h"
23 #include "dcamera_photo_callback.h"
24 #include "dcamera_preview_callback.h"
25 #include "dcamera_session_callback.h"
26 #include "dcamera_utils_tools.h"
27 #include "dcamera_video_callback.h"
28 #include "distributed_camera_constants.h"
29 #include "distributed_camera_errno.h"
30 #include "distributed_hardware_log.h"
31 #include "metadata_utils.h"
32
33 namespace OHOS {
34 namespace DistributedHardware {
DCameraClient(const std::string & dhId)35 DCameraClient::DCameraClient(const std::string& dhId)
36 {
37 DHLOGI("DCameraClient Constructor dhId: %s", GetAnonyString(dhId).c_str());
38 cameraId_ = dhId.substr(CAMERA_ID_PREFIX.size());
39 isInit_ = false;
40 }
41
~DCameraClient()42 DCameraClient::~DCameraClient()
43 {
44 if (isInit_) {
45 UnInit();
46 }
47 }
48
Init()49 int32_t DCameraClient::Init()
50 {
51 DHLOGI("DCameraClient::Init cameraId: %s", GetAnonyString(cameraId_).c_str());
52 cameraManager_ = CameraStandard::CameraManager::GetInstance();
53 if (cameraManager_ == nullptr) {
54 DHLOGE("DCameraClient::Init cameraManager getInstance failed");
55 return DCAMERA_BAD_VALUE;
56 }
57 cameraManager_->SetCallback(std::make_shared<DCameraManagerCallback>());
58
59 std::vector<sptr<CameraStandard::CameraDevice>> cameraList = cameraManager_->GetSupportedCameras();
60 DHLOGI("DCameraClient::Init camera size: %d", cameraList.size());
61 for (auto& info : cameraList) {
62 if (info->GetID() == cameraId_) {
63 DHLOGI("DCameraClient::Init cameraInfo get id: %s", GetAnonyString(info->GetID()).c_str());
64 cameraInfo_ = info;
65 break;
66 }
67 }
68 if (cameraInfo_ == nullptr) {
69 DHLOGE("DCameraClient::Init cameraInfo is null");
70 return DCAMERA_BAD_VALUE;
71 }
72
73 isInit_ = true;
74 DHLOGI("DCameraClient::Init %s success", GetAnonyString(cameraId_).c_str());
75 return DCAMERA_OK;
76 }
77
UnInit()78 int32_t DCameraClient::UnInit()
79 {
80 DHLOGI("DCameraClient::UnInit cameraId: %s", GetAnonyString(cameraId_).c_str());
81 if (cameraManager_ != nullptr) {
82 DHLOGI("DCameraClient::UnInit unregister cameraManager callback");
83 cameraManager_->SetCallback(nullptr);
84 }
85
86 isInit_ = false;
87 cameraInfo_ = nullptr;
88 cameraManager_ = nullptr;
89 DHLOGI("DCameraClient::UnInit %s success", GetAnonyString(cameraId_).c_str());
90 return DCAMERA_OK;
91 }
92
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)93 int32_t DCameraClient::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
94 {
95 DHLOGI("DCameraClient::UpdateSettings cameraId: %s", GetAnonyString(cameraId_).c_str());
96 for (auto& setting : settings) {
97 switch (setting->type_) {
98 case UPDATE_METADATA: {
99 DHLOGI("DCameraClient::UpdateSettings %s update metadata settings", GetAnonyString(cameraId_).c_str());
100 std::string dcSettingValue = setting->value_;
101 std::string metadataStr = Base64Decode(dcSettingValue);
102 FindCameraMetadata(metadataStr);
103
104 if (cameraInput_ == nullptr) {
105 DHLOGE("DCameraClient::UpdateSettings %s cameraInput is null", GetAnonyString(cameraId_).c_str());
106 UpdateSettingCache(metadataStr);
107 return DCAMERA_OK;
108 }
109
110 int32_t ret = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetCameraSettings(metadataStr);
111 if (ret != DCAMERA_OK) {
112 DHLOGE("DCameraClient::UpdateSettings %s update metadata settings failed, ret: %d",
113 GetAnonyString(cameraId_).c_str(), ret);
114 return ret;
115 }
116 break;
117 }
118 default: {
119 DHLOGE("DCameraClient::UpdateSettings unknown setting type");
120 break;
121 }
122 }
123 }
124 DHLOGI("DCameraClient::UpdateSettings %s success", GetAnonyString(cameraId_).c_str());
125 return DCAMERA_OK;
126 }
127
UpdateSettingCache(const std::string & metadataStr)128 void DCameraClient::UpdateSettingCache(const std::string& metadataStr)
129 {
130 if (cameraMetadatas_.size() == DCAMERA_MAX_METADATA_SIZE) {
131 DHLOGE("DCameraClient::UpdateSettingCache %s camera metadata oversize",
132 GetAnonyString(cameraId_).c_str());
133 cameraMetadatas_.pop();
134 }
135 cameraMetadatas_.push(metadataStr);
136 }
137
FindCameraMetadata(const std::string & metadataStr)138 void DCameraClient::FindCameraMetadata(const std::string& metadataStr)
139 {
140 std::shared_ptr<Camera::CameraMetadata> cameraMetadata = Camera::MetadataUtils::DecodeFromString(metadataStr);
141 camera_metadata_item_t focusItem;
142 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_FOCUS_MODE, &focusItem);
143 if (ret == CAM_META_SUCCESS) {
144 DHLOGI("DCameraClient::FindCameraMetadata focus mode: %d", focusItem.data.u8[0]);
145 } else {
146 DHLOGE("DCameraClient::FindCameraMetadata %s find focus mode failed, ret: %d",
147 GetAnonyString(cameraId_).c_str(), ret);
148 }
149
150 camera_metadata_item_t exposureItem;
151 ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_EXPOSURE_MODE, &exposureItem);
152 if (ret == CAM_META_SUCCESS) {
153 DHLOGI("DCameraClient::FindCameraMetadata exposure mode: %d", exposureItem.data.u8[0]);
154 } else {
155 DHLOGE("DCameraClient::FindCameraMetadata %s find exposure mode failed, ret: %d",
156 GetAnonyString(cameraId_).c_str(), ret);
157 }
158
159 camera_metadata_item_t stabilityItem;
160 ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &stabilityItem);
161 if (ret == CAM_META_SUCCESS) {
162 DHLOGI("DCameraClient::FindCameraMetadata stabilization mode: %d", stabilityItem.data.u8[0]);
163 } else {
164 DHLOGE("DCameraClient::FindCameraMetadata %s find stabilization mode failed, ret: %d",
165 GetAnonyString(cameraId_).c_str(), ret);
166 }
167 }
168
StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)169 int32_t DCameraClient::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
170 {
171 DHLOGI("DCameraClient::StartCapture cameraId: %s", GetAnonyString(cameraId_).c_str());
172 if ((photoOutput_ == nullptr) && (previewOutput_ == nullptr)) {
173 DHLOGI("DCameraClient::StartCapture %s config capture session", GetAnonyString(cameraId_).c_str());
174 int32_t ret = ConfigCaptureSession(captureInfos);
175 if (ret != DCAMERA_OK) {
176 DHLOGE("DCameraClient::StartCapture config capture session failed, cameraId: %s, ret: %d",
177 GetAnonyString(cameraId_).c_str(), ret);
178 return CameraServiceErrorType(ret);
179 }
180 }
181
182 for (auto& info : captureInfos) {
183 if ((info->streamType_ == CONTINUOUS_FRAME) || (!info->isCapture_)) {
184 continue;
185 }
186 int32_t ret = StartCaptureInner(info);
187 if (ret != DCAMERA_OK) {
188 DHLOGE("DCameraClient::StartCapture failed, cameraId: %s, ret: %d",
189 GetAnonyString(cameraId_).c_str(), ret);
190 return CameraServiceErrorType(ret);
191 }
192 }
193 DHLOGI("DCameraClient::StartCapture %s success", GetAnonyString(cameraId_).c_str());
194 return DCAMERA_OK;
195 }
196
CameraServiceErrorType(const int32_t errorType)197 int32_t DCameraClient::CameraServiceErrorType(const int32_t errorType)
198 {
199 if (errorType == CameraStandard::CamServiceError::CAMERA_ALLOC_ERROR) {
200 return DCAMERA_ALLOC_ERROR;
201 } else if (errorType == CameraStandard::CamServiceError::CAMERA_DEVICE_BUSY) {
202 return DCAMERA_DEVICE_BUSY;
203 }
204 return errorType;
205 }
206
StopCapture()207 int32_t DCameraClient::StopCapture()
208 {
209 DHLOGI("DCameraClient::StopCapture cameraId: %s", GetAnonyString(cameraId_).c_str());
210
211 if (photoOutput_ != nullptr) {
212 DHLOGI("DCameraClient::StopCapture %s release photoOutput", GetAnonyString(cameraId_).c_str());
213 int32_t ret = photoOutput_->Release();
214 if (ret != DCAMERA_OK) {
215 DHLOGE("DCameraClient::StopCapture photoOutput Release failed, cameraId: %s, ret: %d",
216 GetAnonyString(cameraId_).c_str(), ret);
217 }
218 photoOutput_ = nullptr;
219 }
220 ReleaseCaptureSession();
221 if (cameraInput_ != nullptr) {
222 DHLOGI("DCameraClient::StopCapture %s release cameraInput", GetAnonyString(cameraId_).c_str());
223 int32_t ret = cameraInput_->Release();
224 if (ret != DCAMERA_OK) {
225 DHLOGE("DCameraClient::StopCapture cameraInput Release failed, cameraId: %s, ret: %d",
226 GetAnonyString(cameraId_).c_str(), ret);
227 }
228 cameraInput_ = nullptr;
229 }
230
231 if (videoSurface_ != nullptr) {
232 DHLOGI("DCameraClient::StopCapture %s video surface unregister consumer listener",
233 GetAnonyString(cameraId_).c_str());
234 int32_t ret = videoSurface_->UnregisterConsumerListener();
235 if (ret != DCAMERA_OK) {
236 DHLOGE("DCameraClient::StopCapture %s video surface unregister consumer listener failed, ret: %d",
237 GetAnonyString(cameraId_).c_str(), ret);
238 }
239 videoListener_ = nullptr;
240 videoSurface_ = nullptr;
241 }
242
243 if (photoSurface_ != nullptr) {
244 DHLOGI("DCameraClient::StopCapture %s photo surface unregister consumer listener",
245 GetAnonyString(cameraId_).c_str());
246 int32_t ret = photoSurface_->UnregisterConsumerListener();
247 if (ret != DCAMERA_OK) {
248 DHLOGE("DCameraClient::StopCapture %s photo surface unregister consumer listener failed, ret: %d",
249 GetAnonyString(cameraId_).c_str(), ret);
250 }
251 photoListener_ = nullptr;
252 photoSurface_ = nullptr;
253 }
254
255 previewOutput_ = nullptr;
256 DHLOGI("DCameraClient::StopCapture %s success", GetAnonyString(cameraId_).c_str());
257 return DCAMERA_OK;
258 }
259
ReleaseCaptureSession()260 void DCameraClient::ReleaseCaptureSession()
261 {
262 if (captureSession_ == nullptr) {
263 return;
264 }
265 DHLOGI("DCameraClient::StopCapture %s stop captureSession", GetAnonyString(cameraId_).c_str());
266 int32_t ret = captureSession_->Stop();
267 if (ret != DCAMERA_OK) {
268 DHLOGE("DCameraClient::StopCapture captureSession stop failed, cameraId: %s, ret: %d",
269 GetAnonyString(cameraId_).c_str(), ret);
270 }
271 ret = cameraInput_->Close();
272 if (ret != DCAMERA_OK) {
273 DHLOGE("DCameraClient::StopCapture cameraInput Close failed, cameraId: %s, ret: %d",
274 GetAnonyString(cameraId_).c_str(), ret);
275 }
276 DHLOGI("DCameraClient::StopCapture %s release captureSession", GetAnonyString(cameraId_).c_str());
277 ret = captureSession_->Release();
278 if (ret != DCAMERA_OK) {
279 DHLOGE("DCameraClient::StopCapture captureSession Release failed, cameraId: %s, ret: %d",
280 GetAnonyString(cameraId_).c_str(), ret);
281 }
282 captureSession_ = nullptr;
283 }
284
SetStateCallback(std::shared_ptr<StateCallback> & callback)285 int32_t DCameraClient::SetStateCallback(std::shared_ptr<StateCallback>& callback)
286 {
287 DHLOGI("DCameraClient::SetStateCallback cameraId: %s", GetAnonyString(cameraId_).c_str());
288 if (callback == nullptr) {
289 DHLOGE("DCameraClient::SetStateCallback %s unregistering state callback", GetAnonyString(cameraId_).c_str());
290 }
291 stateCallback_ = callback;
292 return DCAMERA_OK;
293 }
294
SetResultCallback(std::shared_ptr<ResultCallback> & callback)295 int32_t DCameraClient::SetResultCallback(std::shared_ptr<ResultCallback>& callback)
296 {
297 DHLOGI("DCameraClient::SetResultCallback cameraId: %s", GetAnonyString(cameraId_).c_str());
298 if (callback == nullptr) {
299 DHLOGE("DCameraClient::SetResultCallback %s unregistering result callback", GetAnonyString(cameraId_).c_str());
300 }
301 resultCallback_ = callback;
302 return DCAMERA_OK;
303 }
304
ConfigCaptureSession(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)305 int32_t DCameraClient::ConfigCaptureSession(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
306 {
307 DHLOGI("DCameraClient::ConfigCaptureSession cameraId: %s", GetAnonyString(cameraId_).c_str());
308 int rv = cameraManager_->CreateCameraInput(cameraInfo_, &((sptr<CameraStandard::CameraInput> &)cameraInput_));
309 if (rv != DCAMERA_OK) {
310 DHLOGE("DCameraClient::ConfigCaptureSession %s create cameraInput failed", GetAnonyString(cameraId_).c_str());
311 return DCAMERA_BAD_VALUE;
312 }
313 int32_t rc = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->Open();
314 if (rc != DCAMERA_OK) {
315 DHLOGE("DCameraClient::ConfigCaptureSession cameraInput_ Open failed, cameraId: %s, ret: %d",
316 GetAnonyString(cameraId_).c_str(), rc);
317 return DCAMERA_BAD_VALUE;
318 }
319 std::shared_ptr<DCameraInputCallback> inputCallback = std::make_shared<DCameraInputCallback>(stateCallback_);
320 ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetErrorCallback(inputCallback);
321
322 while (!cameraMetadatas_.empty()) {
323 std::string metadataStr = cameraMetadatas_.front();
324 FindCameraMetadata(metadataStr);
325 int32_t ret = ((sptr<CameraStandard::CameraInput> &)cameraInput_)->SetCameraSettings(metadataStr);
326 if (ret != DCAMERA_OK) {
327 DHLOGE("DCameraClient::ConfigCaptureSession %s set camera settings failed, ret: %d",
328 GetAnonyString(cameraId_).c_str(), ret);
329 return ret;
330 }
331 cameraMetadatas_.pop();
332 }
333
334 rv = cameraManager_->CreateCaptureSession(&captureSession_);
335 if (rv != DCAMERA_OK) {
336 DHLOGE("DCameraClient::ConfigCaptureSession %s create captureSession failed",
337 GetAnonyString(cameraId_).c_str());
338 return DCAMERA_BAD_VALUE;
339 }
340
341 std::shared_ptr<DCameraSessionCallback> sessionCallback = std::make_shared<DCameraSessionCallback>(stateCallback_);
342 captureSession_->SetFocusCallback(sessionCallback);
343 captureSession_->SetCallback(sessionCallback);
344
345 int32_t ret = CreateCaptureOutput(captureInfos);
346 if (ret != DCAMERA_OK) {
347 DHLOGE("DCameraClient::ConfigCaptureSession create capture output failed, cameraId: %s, ret: %d",
348 GetAnonyString(cameraId_).c_str(), ret);
349 return ret;
350 }
351
352 return ConfigCaptureSessionInner();
353 }
354
ConfigCaptureSessionInner()355 int32_t DCameraClient::ConfigCaptureSessionInner()
356 {
357 int32_t ret = captureSession_->BeginConfig();
358 if (ret != DCAMERA_OK) {
359 DHLOGE("DCameraClient::ConfigCaptureSession %s config captureSession failed, ret: %d",
360 GetAnonyString(cameraId_).c_str(), ret);
361 return ret;
362 }
363
364 ret = captureSession_->AddInput(cameraInput_);
365 if (ret != DCAMERA_OK) {
366 DHLOGE("DCameraClient::ConfigCaptureSession %s add cameraInput to captureSession failed, ret: %d",
367 GetAnonyString(cameraId_).c_str(), ret);
368 return ret;
369 }
370
371 if (photoOutput_ != nullptr) {
372 ret = captureSession_->AddOutput(photoOutput_);
373 if (ret != DCAMERA_OK) {
374 DHLOGE("DCameraClient::ConfigCaptureSession %s add photoOutput to captureSession failed, ret: %d",
375 GetAnonyString(cameraId_).c_str(), ret);
376 return ret;
377 }
378 }
379
380 if (previewOutput_ != nullptr) {
381 ret = captureSession_->AddOutput(previewOutput_);
382 if (ret != DCAMERA_OK) {
383 DHLOGE("DCameraClient::ConfigCaptureSession %s add videoOutput to captureSession failed, ret: %d",
384 GetAnonyString(cameraId_).c_str(), ret);
385 return ret;
386 }
387 }
388
389 ret = captureSession_->CommitConfig();
390 if (ret != DCAMERA_OK) {
391 DHLOGE("DCameraClient::ConfigCaptureSession %s commit captureSession failed, ret: %d",
392 GetAnonyString(cameraId_).c_str(), ret);
393 return ret;
394 }
395
396 ret = captureSession_->Start();
397 if (ret != DCAMERA_OK) {
398 DHLOGE("DCameraClient::ConfigCaptureSession %s start captureSession failed, ret: %d",
399 GetAnonyString(cameraId_).c_str(), ret);
400 }
401
402 DHLOGI("DCameraClient::ConfigCaptureSession %s success", GetAnonyString(cameraId_).c_str());
403 return DCAMERA_OK;
404 }
405
CreateCaptureOutput(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)406 int32_t DCameraClient::CreateCaptureOutput(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
407 {
408 if (captureInfos.empty()) {
409 DHLOGE("DCameraClient::CreateCaptureOutput no capture info, cameraId: %s", GetAnonyString(cameraId_).c_str());
410 return DCAMERA_BAD_VALUE;
411 }
412
413 for (auto& info : captureInfos) {
414 if (info->streamType_ == SNAPSHOT_FRAME) {
415 int32_t ret = CreatePhotoOutput(info);
416 if (ret != DCAMERA_OK) {
417 DHLOGE("DCameraClient::CreateCaptureOutput %s create photo output failed, ret: %d",
418 GetAnonyString(cameraId_).c_str(), ret);
419 return ret;
420 }
421 } else if (info->streamType_ == CONTINUOUS_FRAME) {
422 int32_t ret = CreateVideoOutput(info);
423 if (ret != DCAMERA_OK) {
424 DHLOGE("DCameraClient::CreateCaptureOutput %s create video output failed, ret: %d",
425 GetAnonyString(cameraId_).c_str(), ret);
426 return ret;
427 }
428 } else {
429 DHLOGE("DCameraClient::CreateCaptureOutput unknown stream type");
430 return DCAMERA_BAD_VALUE;
431 }
432 }
433 return DCAMERA_OK;
434 }
435
CreatePhotoOutput(std::shared_ptr<DCameraCaptureInfo> & info)436 int32_t DCameraClient::CreatePhotoOutput(std::shared_ptr<DCameraCaptureInfo>& info)
437 {
438 DHLOGI("DCameraClient::CreatePhotoOutput camId: %s, width: %d, height: %d, format: %d, stream: %d, isCapture: %d",
439 GetAnonyString(cameraId_).c_str(), info->width_, info->height_, info->format_,
440 info->streamType_, info->isCapture_);
441 photoSurface_ = Surface::CreateSurfaceAsConsumer();
442 photoSurface_->SetDefaultWidthAndHeight(info->width_, info->height_);
443 photoSurface_->SetUserData(CAMERA_SURFACE_FORMAT, std::to_string(info->format_));
444 photoListener_ = new DCameraPhotoSurfaceListener(photoSurface_, resultCallback_);
445 photoSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener> &)photoListener_);
446 CameraStandard::CameraFormat photoFormat = ConvertToCameraFormat(info->format_);
447 CameraStandard::Size photoSize = {info->width_, info->height_};
448 CameraStandard::Profile photoProfile(photoFormat, photoSize);
449 int rv = cameraManager_->CreatePhotoOutput(
450 photoProfile, photoSurface_, &((sptr<CameraStandard::PhotoOutput> &)photoOutput_));
451 if (rv != DCAMERA_OK) {
452 DHLOGE("DCameraClient::CreatePhotoOutput %s create photo output failed", GetAnonyString(cameraId_).c_str());
453 return DCAMERA_BAD_VALUE;
454 }
455 std::shared_ptr<DCameraPhotoCallback> photoCallback = std::make_shared<DCameraPhotoCallback>(stateCallback_);
456 ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->SetCallback(photoCallback);
457 DHLOGI("DCameraClient::CreatePhotoOutput %s success", GetAnonyString(cameraId_).c_str());
458 return DCAMERA_OK;
459 }
460
CreateVideoOutput(std::shared_ptr<DCameraCaptureInfo> & info)461 int32_t DCameraClient::CreateVideoOutput(std::shared_ptr<DCameraCaptureInfo>& info)
462 {
463 DHLOGI("DCameraClient::CreateVideoOutput camId: %s, width: %d, height: %d, format: %d, stream: %d, isCapture: %d",
464 GetAnonyString(cameraId_).c_str(), info->width_, info->height_, info->format_,
465 info->streamType_, info->isCapture_);
466 videoSurface_ = Surface::CreateSurfaceAsConsumer();
467 videoSurface_->SetDefaultWidthAndHeight(info->width_, info->height_);
468 videoSurface_->SetUserData(CAMERA_SURFACE_FORMAT, std::to_string(info->format_));
469 videoListener_ = new DCameraVideoSurfaceListener(videoSurface_, resultCallback_);
470 videoSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener> &)videoListener_);
471 CameraStandard::CameraFormat previewFormat = ConvertToCameraFormat(info->format_);
472 CameraStandard::Size previewSize = {info->width_, info->height_};
473 CameraStandard::Profile previewProfile(previewFormat, previewSize);
474 int rv = cameraManager_->CreatePreviewOutput(
475 previewProfile, videoSurface_, &((sptr<CameraStandard::PreviewOutput> &)previewOutput_));
476 if (rv != DCAMERA_OK) {
477 DHLOGE("DCameraClient::CreatePreviewOutput %s create video output failed", GetAnonyString(cameraId_).c_str());
478 return DCAMERA_BAD_VALUE;
479 }
480 std::shared_ptr<DCameraPreviewCallback> previewCallback = std::make_shared<DCameraPreviewCallback>(stateCallback_);
481 ((sptr<CameraStandard::PreviewOutput> &)previewOutput_)->SetCallback(previewCallback);
482 DHLOGI("DCameraClient::CreateVideoOutput preview output %s success", GetAnonyString(cameraId_).c_str());
483 return DCAMERA_OK;
484 }
485
ConvertToCameraFormat(int32_t format)486 CameraStandard::CameraFormat DCameraClient::ConvertToCameraFormat(int32_t format)
487 {
488 CameraStandard::CameraFormat ret = CameraStandard::CameraFormat::CAMERA_FORMAT_INVALID;
489 DCameraFormat df = static_cast<DCameraFormat>(format);
490 switch (df) {
491 case OHOS_CAMERA_FORMAT_RGBA_8888:
492 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_RGBA_8888;
493 break;
494 case OHOS_CAMERA_FORMAT_YCBCR_420_888:
495 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_YCBCR_420_888;
496 break;
497 case OHOS_CAMERA_FORMAT_YCRCB_420_SP:
498 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_YUV_420_SP;
499 break;
500 case OHOS_CAMERA_FORMAT_JPEG:
501 ret = CameraStandard::CameraFormat::CAMERA_FORMAT_JPEG;
502 break;
503 default:
504 break;
505 }
506 return ret;
507 }
508
StartCaptureInner(std::shared_ptr<DCameraCaptureInfo> & info)509 int32_t DCameraClient::StartCaptureInner(std::shared_ptr<DCameraCaptureInfo>& info)
510 {
511 switch (info->streamType_) {
512 case CONTINUOUS_FRAME: {
513 return StartVideoOutput();
514 }
515 case SNAPSHOT_FRAME: {
516 return StartPhotoOutput(info);
517 }
518 default: {
519 DHLOGE("DCameraClient::StartCaptureInner unknown stream type");
520 return DCAMERA_BAD_VALUE;
521 }
522 }
523 }
524
StartPhotoOutput(std::shared_ptr<DCameraCaptureInfo> & info)525 int32_t DCameraClient::StartPhotoOutput(std::shared_ptr<DCameraCaptureInfo>& info)
526 {
527 DHLOGI("DCameraClient::StartPhotoOutput cameraId: %s", GetAnonyString(cameraId_).c_str());
528 if (photoOutput_ == nullptr) {
529 DHLOGE("DCameraClient::StartPhotoOutput photoOutput is null");
530 return DCAMERA_BAD_VALUE;
531 }
532
533 std::vector<std::shared_ptr<DCameraSettings>> captureSettings = info->captureSettings_;
534 std::string metadataSetting;
535 for (const auto& setting : captureSettings) {
536 if (setting->type_ == UPDATE_METADATA) {
537 DHLOGI("DCameraClient::StartPhotoOutput %s update metadata settings", GetAnonyString(cameraId_).c_str());
538 metadataSetting = setting->value_;
539 }
540 }
541
542 if (metadataSetting.empty()) {
543 DHLOGE("DCameraClient::StartPhotoOutput no metadata settings to update");
544 int32_t ret = ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->Capture();
545 if (ret != DCAMERA_OK) {
546 DHLOGE("DCameraClient::StartPhotoOutput %s photoOutput capture failed, ret: %d",
547 GetAnonyString(cameraId_).c_str(), ret);
548 return ret;
549 }
550 return DCAMERA_OK;
551 }
552
553 std::string metadataStr = Base64Decode(metadataSetting);
554 std::shared_ptr<Camera::CameraMetadata> cameraMetadata = Camera::MetadataUtils::DecodeFromString(metadataStr);
555 std::shared_ptr<CameraStandard::PhotoCaptureSetting> photoCaptureSetting =
556 std::make_shared<CameraStandard::PhotoCaptureSetting>();
557 SetPhotoCaptureRotation(cameraMetadata, photoCaptureSetting);
558 SetPhotoCaptureQuality(cameraMetadata, photoCaptureSetting);
559 SetPhotoCaptureLocation(cameraMetadata, photoCaptureSetting);
560 int32_t ret = ((sptr<CameraStandard::PhotoOutput> &)photoOutput_)->Capture(photoCaptureSetting);
561 if (ret != DCAMERA_OK) {
562 DHLOGE("DCameraClient::StartPhotoOutput %s photoOutput capture failed, ret: %d",
563 GetAnonyString(cameraId_).c_str(), ret);
564 return ret;
565 }
566 return DCAMERA_OK;
567 }
568
SetPhotoCaptureRotation(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)569 void DCameraClient::SetPhotoCaptureRotation(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
570 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
571 {
572 uint32_t rotationCount = 1;
573 camera_metadata_item_t item;
574 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_ORIENTATION, &item);
575 if ((ret == CAM_META_SUCCESS) && (rotationCount == item.count)) {
576 CameraStandard::PhotoCaptureSetting::RotationConfig rotation =
577 static_cast<CameraStandard::PhotoCaptureSetting::RotationConfig>(item.data.i32[0]);
578 photoCaptureSetting->SetRotation(rotation);
579 DHLOGI("DCameraClient::SetPhotoCaptureRotation %s photo capture settings set %d rotation: %d",
580 GetAnonyString(cameraId_).c_str(), item.count, rotation);
581 }
582 }
583
SetPhotoCaptureQuality(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)584 void DCameraClient::SetPhotoCaptureQuality(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
585 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
586 {
587 uint32_t qualityCount = 1;
588 camera_metadata_item_t item;
589 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_QUALITY, &item);
590 if ((ret == CAM_META_SUCCESS) && (qualityCount == item.count)) {
591 CameraStandard::PhotoCaptureSetting::QualityLevel quality =
592 static_cast<CameraStandard::PhotoCaptureSetting::QualityLevel>(item.data.u8[0]);
593 photoCaptureSetting->SetQuality(quality);
594 DHLOGI("DCameraClient::SetPhotoCaptureQuality %s photo capture settings set %d quality: %d",
595 GetAnonyString(cameraId_).c_str(), item.count, quality);
596 }
597 }
598
SetPhotoCaptureLocation(const std::shared_ptr<Camera::CameraMetadata> & cameraMetadata,std::shared_ptr<CameraStandard::PhotoCaptureSetting> & photoCaptureSetting)599 void DCameraClient::SetPhotoCaptureLocation(const std::shared_ptr<Camera::CameraMetadata>& cameraMetadata,
600 std::shared_ptr<CameraStandard::PhotoCaptureSetting>& photoCaptureSetting)
601 {
602 uint32_t locationCount = 3;
603 camera_metadata_item_t item;
604 int32_t ret = Camera::FindCameraMetadataItem(cameraMetadata->get(), OHOS_JPEG_GPS_COORDINATES, &item);
605 if ((ret == CAM_META_SUCCESS) && (locationCount == item.count)) {
606 int32_t latitudeIndex = 0;
607 int32_t longitudeIndex = 1;
608 int32_t altitudeIndex = 2;
609 std::unique_ptr<CameraStandard::Location> location = std::make_unique<CameraStandard::Location>();
610 location->latitude = item.data.d[latitudeIndex];
611 location->longitude = item.data.d[longitudeIndex];
612 location->altitude = item.data.d[altitudeIndex];
613 photoCaptureSetting->SetLocation(location);
614 DHLOGI("DCameraClient::SetPhotoCaptureLocation %s photo capture settings set %d location success",
615 GetAnonyString(cameraId_).c_str(), item.count);
616 }
617 }
618
StartVideoOutput()619 int32_t DCameraClient::StartVideoOutput()
620 {
621 DHLOGI("DCameraClient::StartVideoOutput cameraId: %s", GetAnonyString(cameraId_).c_str());
622 if (videoOutput_ == nullptr) {
623 DHLOGE("DCameraClient::StartVideoOutput videoOutput is null");
624 return DCAMERA_BAD_VALUE;
625 }
626 int32_t ret = ((sptr<CameraStandard::VideoOutput> &)videoOutput_)->Start();
627 if (ret != DCAMERA_OK) {
628 DHLOGE("DCameraClient::StartVideoOutput %s videoOutput start failed, ret: %d",
629 GetAnonyString(cameraId_).c_str(), ret);
630 return ret;
631 }
632 return DCAMERA_OK;
633 }
634 } // namespace DistributedHardware
635 } // namespace OHOS
636