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