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 <mutex>
17 #include <securec.h>
18 #include "camera_metadata_info.h"
19 #include "camera_log.h"
20 #include "input/camera_device.h"
21 #include "metadata_common_utils.h"
22 #include "capture_scene_const.h"
23
24 using namespace std;
25
26 namespace OHOS {
27 namespace CameraStandard {
28 const std::unordered_map<camera_type_enum_t, CameraType> CameraDevice::metaToFwCameraType_ = {
29 {OHOS_CAMERA_TYPE_WIDE_ANGLE, CAMERA_TYPE_WIDE_ANGLE},
30 {OHOS_CAMERA_TYPE_ULTRA_WIDE, CAMERA_TYPE_ULTRA_WIDE},
31 {OHOS_CAMERA_TYPE_TELTPHOTO, CAMERA_TYPE_TELEPHOTO},
32 {OHOS_CAMERA_TYPE_TRUE_DEAPTH, CAMERA_TYPE_TRUE_DEPTH},
33 {OHOS_CAMERA_TYPE_LOGICAL, CAMERA_TYPE_UNSUPPORTED},
34 {OHOS_CAMERA_TYPE_UNSPECIFIED, CAMERA_TYPE_DEFAULT}
35 };
36
37 const std::unordered_map<camera_position_enum_t, CameraPosition> CameraDevice::metaToFwCameraPosition_ = {
38 {OHOS_CAMERA_POSITION_FRONT, CAMERA_POSITION_FRONT},
39 {OHOS_CAMERA_POSITION_BACK, CAMERA_POSITION_BACK},
40 {OHOS_CAMERA_POSITION_OTHER, CAMERA_POSITION_UNSPECIFIED}
41 };
42
43 const std::unordered_map<camera_connection_type_t, ConnectionType> CameraDevice::metaToFwConnectionType_ = {
44 {OHOS_CAMERA_CONNECTION_TYPE_REMOTE, CAMERA_CONNECTION_REMOTE},
45 {OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN, CAMERA_CONNECTION_USB_PLUGIN},
46 {OHOS_CAMERA_CONNECTION_TYPE_BUILTIN, CAMERA_CONNECTION_BUILT_IN}
47 };
48
49 const std::unordered_map<camera_foldscreen_enum_t, CameraFoldScreenType> CameraDevice::metaToFwCameraFoldScreenType_ = {
50 {OHOS_CAMERA_FOLDSCREEN_INNER, CAMERA_FOLDSCREEN_INNER},
51 {OHOS_CAMERA_FOLDSCREEN_OUTER, CAMERA_FOLDSCREEN_OUTER},
52 {OHOS_CAMERA_FOLDSCREEN_OTHER, CAMERA_FOLDSCREEN_UNSPECIFIED}
53 };
54
CameraDevice(std::string cameraID,std::shared_ptr<Camera::CameraMetadata> metadata)55 CameraDevice::CameraDevice(std::string cameraID, std::shared_ptr<Camera::CameraMetadata> metadata)
56 : cameraID_(cameraID), baseAbility_(MetadataCommonUtils::CopyMetadata(metadata)),
57 cachedMetadata_(MetadataCommonUtils::CopyMetadata(metadata))
58 {
59 if (metadata != nullptr) {
60 init(metadata->get());
61 }
62 }
63
CameraDevice(std::string cameraID,std::shared_ptr<OHOS::Camera::CameraMetadata> metadata,dmDeviceInfo deviceInfo)64 CameraDevice::CameraDevice(
65 std::string cameraID, std::shared_ptr<OHOS::Camera::CameraMetadata> metadata, dmDeviceInfo deviceInfo)
66 : cameraID_(cameraID), baseAbility_(MetadataCommonUtils::CopyMetadata(metadata)),
67 cachedMetadata_(MetadataCommonUtils::CopyMetadata(metadata))
68 {
69 dmDeviceInfo_.deviceName = deviceInfo.deviceName;
70 dmDeviceInfo_.deviceTypeId = deviceInfo.deviceTypeId;
71 dmDeviceInfo_.networkId = deviceInfo.networkId;
72 MEDIA_INFO_LOG("camera cameraid = %{public}s, devicename: = %{public}s", cameraID_.c_str(),
73 dmDeviceInfo_.deviceName.c_str());
74 if (metadata != nullptr) {
75 init(metadata->get());
76 }
77 }
78
isFindModuleTypeTag(uint32_t & tagId)79 bool CameraDevice::isFindModuleTypeTag(uint32_t &tagId)
80 {
81 std::vector<vendorTag_t> infos;
82 int32_t ret = OHOS::Camera::GetAllVendorTags(infos);
83 if (ret == CAM_META_SUCCESS) {
84 for (auto info : infos) {
85 std::string tagName = info.tagName;
86 if (tagName == "hwSensorName") {
87 tagId = info.tagId;
88 return true;
89 }
90 }
91 }
92 return false;
93 }
94
init(common_metadata_header_t * metadata)95 void CameraDevice::init(common_metadata_header_t* metadata)
96 {
97 camera_metadata_item_t item;
98
99 int ret = Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_POSITION, &item);
100 if (ret == CAM_META_SUCCESS) {
101 auto itr = metaToFwCameraPosition_.find(static_cast<camera_position_enum_t>(item.data.u8[0]));
102 if (itr != metaToFwCameraPosition_.end()) {
103 cameraPosition_ = itr->second;
104 }
105 }
106
107 ret = Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_TYPE, &item);
108 if (ret == CAM_META_SUCCESS) {
109 auto itr = metaToFwCameraType_.find(static_cast<camera_type_enum_t>(item.data.u8[0]));
110 if (itr != metaToFwCameraType_.end()) {
111 cameraType_ = itr->second;
112 }
113 }
114
115 ret = Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
116 if (ret == CAM_META_SUCCESS) {
117 auto itr = metaToFwConnectionType_.find(static_cast<camera_connection_type_t>(item.data.u8[0]));
118 if (itr != metaToFwConnectionType_.end()) {
119 connectionType_ = itr->second;
120 }
121 }
122
123 ret = Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_FOLDSCREEN_TYPE, &item);
124 if (ret == CAM_META_SUCCESS) {
125 auto itr = metaToFwCameraFoldScreenType_.find(static_cast<camera_foldscreen_enum_t>(item.data.u8[0]));
126 if (itr != metaToFwCameraFoldScreenType_.end()) {
127 foldScreenType_ = itr->second;
128 }
129 }
130
131 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_SENSOR_ORIENTATION, &item);
132 if (ret == CAM_META_SUCCESS) {
133 cameraOrientation_ = static_cast<uint32_t>(item.data.i32[0]);
134 }
135
136 uint32_t moduleTypeTagId;
137 if (isFindModuleTypeTag(moduleTypeTagId)) {
138 ret = Camera::FindCameraMetadataItem(metadata, moduleTypeTagId, &item);
139 if (ret == CAM_META_SUCCESS) {
140 moduleType_ = item.data.ui32[0];
141 }
142 }
143
144 ret = OHOS::Camera::FindCameraMetadataItem(metadata, OHOS_ABILITY_CAMERA_FOLD_STATUS, &item);
145
146 foldStatus_ = (ret == CAM_META_SUCCESS) ? item.data.u8[0] : OHOS_CAMERA_FOLD_STATUS_NONFOLDABLE;
147
148 MEDIA_INFO_LOG("camera position: %{public}d, camera type: %{public}d, camera connection type: %{public}d, "
149 "camera foldScreen type: %{public}d, camera orientation: %{public}d, "
150 "moduleType: %{public}u, foldStatus: %{public}d", cameraPosition_, cameraType_, connectionType_,
151 foldScreenType_, cameraOrientation_, moduleType_, foldStatus_);
152 }
153
GetID()154 std::string CameraDevice::GetID()
155 {
156 return cameraID_;
157 }
158
GetMetadata()159 std::shared_ptr<Camera::CameraMetadata> CameraDevice::GetMetadata()
160 {
161 std::lock_guard<std::mutex> lock(cachedMetadataMutex_);
162 return cachedMetadata_;
163 }
164
ResetMetadata()165 void CameraDevice::ResetMetadata()
166 {
167 std::lock_guard<std::mutex> lock(cachedMetadataMutex_);
168 cachedMetadata_ = MetadataCommonUtils::CopyMetadata(baseAbility_);
169 }
170
GetCameraAbility()171 const std::shared_ptr<OHOS::Camera::CameraMetadata> CameraDevice::GetCameraAbility()
172 {
173 return baseAbility_;
174 }
175
GetPosition()176 CameraPosition CameraDevice::GetPosition()
177 {
178 // Compatible with adaptive applications
179 if (cameraPosition_ == CAMERA_POSITION_FRONT && foldScreenType_ == CAMERA_FOLDSCREEN_INNER) {
180 cameraPosition_ = CAMERA_POSITION_FOLD_INNER;
181 }
182 return cameraPosition_;
183 }
184
GetUsedAsPosition()185 CameraPosition CameraDevice::GetUsedAsPosition()
186 {
187 return usedAsCameraPosition_;
188 }
189
GetCameraType()190 CameraType CameraDevice::GetCameraType()
191 {
192 return cameraType_;
193 }
194
GetConnectionType()195 ConnectionType CameraDevice::GetConnectionType()
196 {
197 return connectionType_;
198 }
199
GetCameraFoldScreenType()200 CameraFoldScreenType CameraDevice::GetCameraFoldScreenType()
201 {
202 return foldScreenType_;
203 }
204
GetHostName()205 std::string CameraDevice::GetHostName()
206 {
207 return dmDeviceInfo_.deviceName;
208 }
209
GetDeviceType()210 uint16_t CameraDevice::GetDeviceType()
211 {
212 return dmDeviceInfo_.deviceTypeId;
213 }
214
GetNetWorkId()215 std::string CameraDevice::GetNetWorkId()
216 {
217 return dmDeviceInfo_.networkId;
218 }
219
GetCameraOrientation()220 uint32_t CameraDevice::GetCameraOrientation()
221 {
222 return cameraOrientation_;
223 }
224
GetModuleType()225 uint32_t CameraDevice::GetModuleType()
226 {
227 return moduleType_;
228 }
229
GetZoomRatioRange()230 std::vector<float> CameraDevice::GetZoomRatioRange()
231 {
232 int32_t minIndex = 0;
233 int32_t maxIndex = 1;
234 std::vector<float> range;
235
236 if (!zoomRatioRange_.empty()) {
237 return zoomRatioRange_;
238 }
239
240 int ret;
241 uint32_t zoomRangeCount = 2;
242 camera_metadata_item_t item;
243
244 ret = Camera::FindCameraMetadataItem(baseAbility_->get(), OHOS_ABILITY_ZOOM_RATIO_RANGE, &item);
245 CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, {},
246 "Failed to get zoom ratio range with return code %{public}d", ret);
247 CHECK_ERROR_RETURN_RET_LOG(item.count != zoomRangeCount, {},
248 "Failed to get zoom ratio range with return code %{public}d", ret);
249 range = {item.data.f[minIndex], item.data.f[maxIndex]};
250 CHECK_ERROR_RETURN_RET_LOG(range[minIndex] > range[maxIndex], {},
251 "Invalid zoom range. min: %{public}f, max: %{public}f", range[minIndex], range[maxIndex]);
252 MEDIA_DEBUG_LOG("Zoom range min: %{public}f, max: %{public}f", range[minIndex], range[maxIndex]);
253
254 zoomRatioRange_ = range;
255 return zoomRatioRange_;
256 }
257
SetProfile(sptr<CameraOutputCapability> capability)258 void CameraDevice::SetProfile(sptr<CameraOutputCapability> capability)
259 {
260 if (capability == nullptr) {
261 return;
262 }
263 modePreviewProfiles_[NORMAL] = capability->GetPreviewProfiles();
264 modePhotoProfiles_[NORMAL] = capability->GetPhotoProfiles();
265 modeVideoProfiles_[NORMAL] = capability->GetVideoProfiles();
266 modePreviewProfiles_[CAPTURE] = capability->GetPreviewProfiles();
267 modePhotoProfiles_[CAPTURE] = capability->GetPhotoProfiles();
268 modePreviewProfiles_[VIDEO] = capability->GetPreviewProfiles();
269 modePhotoProfiles_[VIDEO] = capability->GetPhotoProfiles();
270 modeVideoProfiles_[VIDEO] = capability->GetVideoProfiles();
271 }
272
SetProfile(sptr<CameraOutputCapability> capability,int32_t modeName)273 void CameraDevice::SetProfile(sptr<CameraOutputCapability> capability, int32_t modeName)
274 {
275 if (capability == nullptr) {
276 return;
277 }
278 modePreviewProfiles_[modeName] = capability->GetPreviewProfiles();
279 modePhotoProfiles_[modeName] = capability->GetPhotoProfiles();
280 modeVideoProfiles_[modeName] = capability->GetVideoProfiles();
281 }
282
GetExposureBiasRange()283 std::vector<float> CameraDevice::GetExposureBiasRange()
284 {
285 int32_t minIndex = 0;
286 int32_t maxIndex = 1;
287 std::vector<int32_t> range;
288
289 if (!exposureBiasRange_.empty()) {
290 return exposureBiasRange_;
291 }
292
293 int ret;
294 uint32_t biasRangeCount = 2;
295 camera_metadata_item_t item;
296 auto metadata = GetMetadata();
297 ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_AE_COMPENSATION_RANGE, &item);
298 if (ret != CAM_META_SUCCESS) {
299 MEDIA_ERR_LOG("Failed to get exposure compensation range with return code %{public}d", ret);
300 return {};
301 }
302 CHECK_ERROR_RETURN_RET_LOG(item.count != biasRangeCount, {},
303 "Invalid exposure compensation range count: %{public}d", item.count);
304
305 range = { item.data.i32[minIndex], item.data.i32[maxIndex] };
306 CHECK_ERROR_RETURN_RET_LOG(range[minIndex] > range[maxIndex], {},
307 "Invalid exposure compensation range. min: %{public}d, max: %{public}d", range[minIndex], range[maxIndex]);
308
309 MEDIA_DEBUG_LOG("Exposure hdi compensation min: %{public}d, max: %{public}d", range[minIndex], range[maxIndex]);
310 exposureBiasRange_ = { range[minIndex], range[maxIndex] };
311 return exposureBiasRange_;
312 }
313
SetCameraDeviceUsedAsPosition(CameraPosition usedAsPosition)314 void CameraDevice::SetCameraDeviceUsedAsPosition(CameraPosition usedAsPosition)
315 {
316 MEDIA_INFO_LOG("CameraDevice::SetCameraDeviceUsedAsPosition params: %{public}u", usedAsPosition);
317 usedAsCameraPosition_ = usedAsPosition;
318 }
319
GetSupportedFoldStatus()320 uint32_t CameraDevice::GetSupportedFoldStatus()
321 {
322 return foldStatus_;
323 }
324 } // namespace CameraStandard
325 } // namespace OHOS
326