1 /*
2 * Copyright (c) 2023-2023 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 "metadata_common_utils.h"
17 #include "camera_metadata_operator.h"
18 #include "camera_util.h"
19 #include <cstdint>
20 #include <memory>
21
22 #include "camera_log.h"
23 #include "capture_session.h"
24
25 namespace OHOS {
26 namespace CameraStandard {
27 namespace {
28 const std::unordered_map<uint32_t, MetadataObjectType> g_HALResultToFwCameraMetaDetect_ = {
29 {OHOS_STATISTICS_DETECT_HUMAN_FACE_INFOS, MetadataObjectType::FACE},
30 {OHOS_STATISTICS_DETECT_HUMAN_BODY_INFOS, MetadataObjectType::HUMAN_BODY},
31 {OHOS_STATISTICS_DETECT_CAT_FACE_INFOS, MetadataObjectType::CAT_FACE},
32 {OHOS_STATISTICS_DETECT_CAT_BODY_INFOS, MetadataObjectType::CAT_BODY},
33 {OHOS_STATISTICS_DETECT_DOG_FACE_INFOS, MetadataObjectType::DOG_FACE},
34 {OHOS_STATISTICS_DETECT_DOG_BODY_INFOS, MetadataObjectType::DOG_BODY},
35 {OHOS_STATISTICS_DETECT_SALIENT_INFOS, MetadataObjectType::SALIENT_DETECTION},
36 {OHOS_STATISTICS_DETECT_BAR_CODE_INFOS, MetadataObjectType::BAR_CODE_DETECTION},
37 {OHOS_STATISTICS_DETECT_BASE_FACE_INFO, MetadataObjectType::BASE_FACE_DETECTION},
38 };
39
40 std::vector<uint32_t> g_typesOfMetadata = {
41 OHOS_STATISTICS_DETECT_HUMAN_FACE_INFOS,
42 OHOS_STATISTICS_DETECT_HUMAN_BODY_INFOS,
43 OHOS_STATISTICS_DETECT_CAT_FACE_INFOS,
44 OHOS_STATISTICS_DETECT_CAT_BODY_INFOS,
45 OHOS_STATISTICS_DETECT_DOG_FACE_INFOS,
46 OHOS_STATISTICS_DETECT_DOG_BODY_INFOS,
47 OHOS_STATISTICS_DETECT_SALIENT_INFOS,
48 OHOS_STATISTICS_DETECT_BAR_CODE_INFOS,
49 OHOS_STATISTICS_DETECT_BASE_FACE_INFO};
50
FillSizeListFromStreamInfo(vector<Size> & sizeList,const StreamInfo & streamInfo,const camera_format_t targetFormat)51 void FillSizeListFromStreamInfo(
52 vector<Size>& sizeList, const StreamInfo& streamInfo, const camera_format_t targetFormat)
53 {
54 // LCOV_EXCL_START
55 for (const auto &detail : streamInfo.detailInfos) {
56 camera_format_t hdi_format = static_cast<camera_format_t>(detail.format);
57 if (hdi_format != targetFormat) {
58 continue;
59 }
60 Size size { .width = detail.width, .height = detail.height };
61 sizeList.emplace_back(size);
62 }
63 // LCOV_EXCL_STOP
64 }
65
FillSizeListFromStreamInfo(vector<Size> & sizeList,const StreamRelatedInfo & streamInfo,const camera_format_t targetFormat)66 void FillSizeListFromStreamInfo(
67 vector<Size>& sizeList, const StreamRelatedInfo& streamInfo, const camera_format_t targetFormat)
68 {
69 // LCOV_EXCL_START
70 for (const auto &detail : streamInfo.detailInfo) {
71 camera_format_t hdi_format = static_cast<camera_format_t>(detail.format);
72 if (hdi_format != targetFormat) {
73 continue;
74 }
75 Size size{.width = detail.width, .height = detail.height};
76 sizeList.emplace_back(size);
77 }
78 // LCOV_EXCL_STOP
79 }
80
GetSupportedPreviewSizeRangeFromProfileLevel(const int32_t modeName,camera_format_t targetFormat,const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)81 std::shared_ptr<vector<Size>> GetSupportedPreviewSizeRangeFromProfileLevel(
82 const int32_t modeName, camera_format_t targetFormat, const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
83 {
84 // LCOV_EXCL_START
85 CHECK_RETURN_RET(metadata == nullptr, nullptr);
86 camera_metadata_item_t item;
87 int32_t retCode = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL, &item);
88 CHECK_RETURN_RET(retCode != CAM_META_SUCCESS || item.count == 0, nullptr);
89 std::shared_ptr<vector<Size>> sizeList = std::make_shared<vector<Size>>();
90 std::vector<SpecInfo> specInfos;
91 ProfileLevelInfo modeInfo = {};
92 CameraAbilityParseUtil::GetModeInfo(modeName, item, modeInfo);
93 specInfos.insert(specInfos.end(), modeInfo.specInfos.begin(), modeInfo.specInfos.end());
94 for (SpecInfo& specInfo : specInfos) {
95 for (StreamInfo& streamInfo : specInfo.streamInfos) {
96 CHECK_EXECUTE(streamInfo.streamType == 0,
97 FillSizeListFromStreamInfo(*sizeList.get(), streamInfo, targetFormat));
98 }
99 }
100 MEDIA_INFO_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRangeFromProfileLevel listSize: %{public}d",
101 static_cast<int>(sizeList->size()));
102 return sizeList;
103 // LCOV_EXCL_STOP
104 }
105
GetSupportedPreviewSizeRangeFromExtendConfig(const int32_t modeName,camera_format_t targetFormat,const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)106 std::shared_ptr<vector<Size>> GetSupportedPreviewSizeRangeFromExtendConfig(
107 const int32_t modeName, camera_format_t targetFormat, const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
108 {
109 // LCOV_EXCL_START
110 auto item = MetadataCommonUtils::GetCapabilityEntry(metadata, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS);
111 CHECK_RETURN_RET(item == nullptr, nullptr);
112 std::shared_ptr<vector<Size>> sizeList = std::make_shared<vector<Size>>();
113
114 ExtendInfo extendInfo = {};
115 std::shared_ptr<CameraStreamInfoParse> modeStreamParse = std::make_shared<CameraStreamInfoParse>();
116 modeStreamParse->getModeInfo(item->data.i32, item->count, extendInfo); // 解析tag中带的数据信息意义
117 for (uint32_t modeIndex = 0; modeIndex < extendInfo.modeCount; modeIndex++) {
118 auto modeInfo = std::move(extendInfo.modeInfo[modeIndex]);
119 MEDIA_DEBUG_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRangeFromExtendConfig check modeName: %{public}d",
120 modeInfo.modeName);
121 if (modeName != modeInfo.modeName) {
122 continue;
123 }
124 for (uint32_t streamIndex = 0; streamIndex < modeInfo.streamTypeCount; streamIndex++) {
125 auto streamInfo = std::move(modeInfo.streamInfo[streamIndex]);
126 int32_t streamType = streamInfo.streamType;
127 MEDIA_DEBUG_LOG(
128 "MetadataCommonUtils::GetSupportedPreviewSizeRangeFromExtendConfig check streamType: %{public}d",
129 streamType);
130 if (streamType != 0) { // Stremp type 0 is preview type.
131 continue;
132 }
133 FillSizeListFromStreamInfo(*sizeList.get(), streamInfo, targetFormat);
134 }
135 }
136 MEDIA_INFO_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRangeFromExtendConfig listSize: %{public}d",
137 static_cast<int>(sizeList->size()));
138 return sizeList;
139 // LCOV_EXCL_STOP
140 }
141
GetSupportedPreviewSizeRangeFromBasicConfig(camera_format_t targetFormat,const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)142 std::shared_ptr<vector<Size>> GetSupportedPreviewSizeRangeFromBasicConfig(
143 camera_format_t targetFormat, const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
144 {
145 // LCOV_EXCL_START
146 auto item = MetadataCommonUtils::GetCapabilityEntry(metadata, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS);
147 CHECK_RETURN_RET(item == nullptr, nullptr);
148 std::shared_ptr<vector<Size>> sizeList = std::make_shared<vector<Size>>();
149
150 const uint32_t widthOffset = 1;
151 const uint32_t heightOffset = 2;
152 const uint32_t unitStep = 3;
153
154 for (uint32_t i = 0; i < item->count; i += unitStep) {
155 camera_format_t hdi_format = static_cast<camera_format_t>(item->data.i32[i]);
156 if (hdi_format != targetFormat) {
157 continue;
158 }
159 Size size;
160 size.width = static_cast<uint32_t>(item->data.i32[i + widthOffset]);
161 size.height = static_cast<uint32_t>(item->data.i32[i + heightOffset]);
162 sizeList->emplace_back(size);
163 }
164 MEDIA_INFO_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRangeFromBasicConfig listSize: %{public}d",
165 static_cast<int>(sizeList->size()));
166 return sizeList;
167 // LCOV_EXCL_STOP
168 }
169 } // namespace
170
GetCapabilityEntry(const std::shared_ptr<Camera::CameraMetadata> metadata,uint32_t metadataTag)171 std::shared_ptr<camera_metadata_item_t> MetadataCommonUtils::GetCapabilityEntry(
172 const std::shared_ptr<Camera::CameraMetadata> metadata, uint32_t metadataTag)
173 {
174 CHECK_RETURN_RET(metadata == nullptr, nullptr);
175 std::shared_ptr<camera_metadata_item_t> item = std::make_shared<camera_metadata_item_t>();
176 int32_t retCode = Camera::FindCameraMetadataItem(metadata->get(), metadataTag, item.get());
177 CHECK_RETURN_RET(retCode != CAM_META_SUCCESS || item->count == 0, nullptr);
178 return item;
179 }
180
GetSupportedPreviewSizeRange(const int32_t modeName,camera_format_t targetFormat,const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)181 std::shared_ptr<vector<Size>> MetadataCommonUtils::GetSupportedPreviewSizeRange(
182 const int32_t modeName, camera_format_t targetFormat, const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
183 {
184 // LCOV_EXCL_START
185 MEDIA_DEBUG_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRange modeName: %{public}d, targetFormat:%{public}d",
186 modeName, targetFormat);
187 std::shared_ptr<vector<Size>> sizeList = std::make_shared<vector<Size>>();
188 auto levelList = GetSupportedPreviewSizeRangeFromProfileLevel(modeName, targetFormat, metadata);
189 if (levelList && levelList->empty() && (modeName == SceneMode::CAPTURE || modeName == SceneMode::VIDEO)) {
190 levelList = GetSupportedPreviewSizeRangeFromProfileLevel(SceneMode::NORMAL, targetFormat, metadata);
191 }
192 if (levelList && !levelList->empty()) {
193 for (auto& size : *levelList) {
194 MEDIA_DEBUG_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRange level info:%{public}dx%{public}d",
195 size.width, size.height);
196 }
197 sizeList->insert(sizeList->end(), levelList->begin(), levelList->end());
198 return sizeList;
199 }
200
201 auto extendList = GetSupportedPreviewSizeRangeFromExtendConfig(modeName, targetFormat, metadata);
202 if (extendList != nullptr && extendList->empty() &&
203 (modeName == SceneMode::CAPTURE || modeName == SceneMode::VIDEO)) {
204 extendList = GetSupportedPreviewSizeRangeFromExtendConfig(SceneMode::NORMAL, targetFormat, metadata);
205 }
206 if (extendList != nullptr && !extendList->empty()) {
207 for (auto& size : *extendList) {
208 MEDIA_DEBUG_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRange extend info:%{public}dx%{public}d",
209 size.width, size.height);
210 }
211 sizeList->insert(sizeList->end(), extendList->begin(), extendList->end());
212 return sizeList;
213 }
214 auto basicList = GetSupportedPreviewSizeRangeFromBasicConfig(targetFormat, metadata);
215 if (basicList != nullptr && !basicList->empty()) {
216 for (auto& size : *basicList) {
217 MEDIA_DEBUG_LOG("MetadataCommonUtils::GetSupportedPreviewSizeRange basic info:%{public}dx%{public}d",
218 size.width, size.height);
219 }
220 sizeList->insert(sizeList->end(), basicList->begin(), basicList->end());
221 }
222 return sizeList;
223 // LCOV_EXCL_STOP
224 }
225
CopyMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)226 std::shared_ptr<OHOS::Camera::CameraMetadata> MetadataCommonUtils::CopyMetadata(
227 const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)
228 {
229 return OHOS::CameraStandard::CopyMetadata(srcMetadata);
230 }
231
ProcessFocusTrackingModeInfo(const std::shared_ptr<OHOS::Camera::CameraMetadata> & metadata,FocusTrackingMode & mode)232 bool MetadataCommonUtils::ProcessFocusTrackingModeInfo(const std::shared_ptr<OHOS::Camera::CameraMetadata>& metadata,
233 FocusTrackingMode& mode)
234 {
235 // LCOV_EXCL_START
236 CHECK_RETURN_RET_ELOG(metadata == nullptr, false, "metadata is nullptr");
237 camera_metadata_item_t item;
238 int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FOCUS_TRACKING_MODE, &item);
239 if (ret != CAM_META_SUCCESS || item.count == 0) {
240 MEDIA_DEBUG_LOG("%{public}s FindCameraMetadataItem failed", __FUNCTION__);
241 return false;
242 }
243 mode = static_cast<FocusTrackingMode>(item.data.u8[0]);
244 return true;
245 // LCOV_EXCL_STOP
246 }
247
ProcessMetaObjects(const int32_t streamId,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result,std::vector<sptr<MetadataObject>> & metaObjects,bool isNeedMirror,bool isNeedFlip,RectBoxType type)248 bool MetadataCommonUtils::ProcessMetaObjects(const int32_t streamId,
249 const std::shared_ptr<OHOS::Camera::CameraMetadata>& result,
250 std::vector<sptr<MetadataObject>> &metaObjects, bool isNeedMirror, bool isNeedFlip, RectBoxType type)
251 {
252 CHECK_RETURN_RET(result == nullptr, false);
253 // camera_metadata_item_t metadataItem;
254 // LCOV_EXCL_START
255 common_metadata_header_t *metadata = result->get();
256 std::vector<camera_metadata_item_t> metadataResults;
257 std::vector<uint32_t> metadataTypes;
258 GetMetadataResults(metadata, metadataResults, metadataTypes);
259 if (metadataResults.size() == 0) {
260 metaObjects.clear();
261 MEDIA_ERR_LOG("Camera not ProcessFaceRectangles");
262 return false;
263 }
264 int32_t ret = ProcessMetaObjects(streamId, metaObjects, metadataResults, metadataTypes,
265 isNeedMirror, isNeedFlip, type);
266 CHECK_RETURN_RET_ELOG(ret != CameraErrorCode::SUCCESS, false,
267 "MetadataCommonUtils::ProcessFaceRectangles() is failed.");
268 return true;
269 // LCOV_EXCL_STOP
270 }
271
GetMetadataResults(const common_metadata_header_t * metadata,std::vector<camera_metadata_item_t> & metadataResults,std::vector<uint32_t> & metadataTypes)272 void MetadataCommonUtils::GetMetadataResults(const common_metadata_header_t *metadata,
273 std::vector<camera_metadata_item_t>& metadataResults, std::vector<uint32_t>& metadataTypes)
274 {
275 // LCOV_EXCL_START
276 for (auto itr : g_typesOfMetadata) {
277 camera_metadata_item_t item;
278 int ret = Camera::FindCameraMetadataItem(metadata, itr, &item);
279 if (ret == CAM_META_SUCCESS) {
280 metadataResults.emplace_back(std::move(item));
281 metadataTypes.emplace_back(itr);
282 }
283 }
284 // LCOV_EXCL_STOP
285 }
286
ProcessMetaObjects(const int32_t streamId,std::vector<sptr<MetadataObject>> & metaObjects,const std::vector<camera_metadata_item_t> & metadataItem,const std::vector<uint32_t> & metadataTypes,bool isNeedMirror,bool isNeedFlip,RectBoxType type)287 int32_t MetadataCommonUtils::ProcessMetaObjects(const int32_t streamId, std::vector<sptr<MetadataObject>>& metaObjects,
288 const std::vector<camera_metadata_item_t>& metadataItem,
289 const std::vector<uint32_t>& metadataTypes,
290 bool isNeedMirror, bool isNeedFlip, RectBoxType type)
291 {
292 // LCOV_EXCL_START
293 for (size_t i = 0; i < metadataItem.size(); ++i) {
294 auto itr = g_HALResultToFwCameraMetaDetect_.find(metadataTypes[i]);
295 if (itr != g_HALResultToFwCameraMetaDetect_.end()) {
296 GenerateObjects(metadataItem[i], itr->second, metaObjects, isNeedMirror, isNeedFlip, type);
297 } else {
298 MEDIA_ERR_LOG("MetadataOutput::ProcessMetaObjects() unsupported type: %{public}d", metadataTypes[i]);
299 }
300 }
301 return CameraErrorCode::SUCCESS;
302 // LCOV_EXCL_STOP
303 }
304
GenerateObjects(const camera_metadata_item_t & metadataItem,MetadataObjectType metadataType,std::vector<sptr<MetadataObject>> & metaObjects,bool isNeedMirror,bool isNeedFlip,RectBoxType rectBoxType)305 void MetadataCommonUtils::GenerateObjects(const camera_metadata_item_t &metadataItem, MetadataObjectType metadataType,
306 std::vector<sptr<MetadataObject>> &metaObjects,
307 bool isNeedMirror, bool isNeedFlip, RectBoxType rectBoxType)
308 {
309 int32_t index = 0;
310 int32_t countOfObject = 0;
311 auto iteratorOfLengthMap = mapLengthOfType.find(metadataType);
312 if (iteratorOfLengthMap != mapLengthOfType.end()) {
313 countOfObject = metadataItem.count / iteratorOfLengthMap->second;
314 }
315 // LCOV_EXCL_START
316 for (int32_t itr = 0; itr < countOfObject; ++itr) {
317 sptr<MetadataObjectFactory> objectFactoryPtr = MetadataObjectFactory::GetInstance();
318 MetadataObjectType typeFromHal = static_cast<MetadataObjectType>(metadataItem.data.i32[index]);
319 index++;
320 ProcessBaseInfo(objectFactoryPtr, metadataItem, index, typeFromHal, isNeedMirror, isNeedFlip, rectBoxType);
321 ProcessExternInfo(objectFactoryPtr, metadataItem, index, typeFromHal, isNeedMirror, isNeedFlip, rectBoxType);
322 metaObjects.push_back(objectFactoryPtr->createMetadataObject(metadataType));
323 }
324 // LCOV_EXCL_STOP
325 }
326
ProcessBaseInfo(sptr<MetadataObjectFactory> factoryPtr,const camera_metadata_item_t & metadataItem,int32_t & index,MetadataObjectType typeFromHal,bool isNeedMirror,bool isNeedFlip,RectBoxType type)327 void MetadataCommonUtils::ProcessBaseInfo(sptr<MetadataObjectFactory> factoryPtr,
328 const camera_metadata_item_t &metadataItem, int32_t &index, MetadataObjectType typeFromHal,
329 bool isNeedMirror, bool isNeedFlip, RectBoxType type)
330 {
331 // LCOV_EXCL_START
332 const int32_t rectLength = 4;
333 const int32_t offsetOne = 1;
334 const int32_t offsetTwo = 2;
335 const int32_t offsetThree = 3;
336 factoryPtr->SetType(typeFromHal)
337 ->SetObjectId(metadataItem.data.i32[index]);
338 index++;
339 factoryPtr->SetTimestamp(metadataItem.data.i32[index]);
340 index++;
341 factoryPtr->SetBox(ProcessRectBox(metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
342 metadataItem.data.i32[index + offsetTwo],
343 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
344 index += rectLength;
345 factoryPtr->SetConfidence(metadataItem.data.i32[index]);
346 index++;
347 int32_t externalLength = metadataItem.data.i32[index];
348 index++;
349 MEDIA_DEBUG_LOG("MetadataOutput::GenerateObjects, type: %{public}d, externalLength: %{public}d", typeFromHal,
350 externalLength);
351 // LCOV_EXCL_STOP
352 }
353
ProcessHumanFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,const camera_metadata_item_t & metadataItem,int32_t & index,bool isNeedMirror,bool isNeedFlip,RectBoxType type)354 void MetadataCommonUtils::ProcessHumanFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,
355 const camera_metadata_item_t &metadataItem, int32_t &index, bool isNeedMirror, bool isNeedFlip, RectBoxType type)
356 {
357 // LCOV_EXCL_START
358 int32_t version = metadataItem.data.i32[index++];
359 MEDIA_DEBUG_LOG("isNeedMirror: %{public}d, isNeedFlip: %{public}d, version: %{public}d",
360 isNeedMirror, isNeedFlip, version);
361 const int32_t rectLength = 4;
362 const int32_t offsetOne = 1;
363 const int32_t offsetTwo = 2;
364 const int32_t offsetThree = 3;
365 factoryPtr->SetLeftEyeBoundingBox(ProcessRectBox(
366 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
367 metadataItem.data.i32[index + offsetTwo],
368 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
369 index += rectLength;
370 factoryPtr->SetRightEyeBoundingBoxd(ProcessRectBox(
371 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
372 metadataItem.data.i32[index + offsetTwo],
373 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
374 index += rectLength;
375 factoryPtr->SetEmotion(static_cast<Emotion>(metadataItem.data.i32[index]));
376 index++;
377 factoryPtr->SetEmotionConfidence(static_cast<Emotion>(metadataItem.data.i32[index]));
378 index++;
379 factoryPtr->SetPitchAngle(metadataItem.data.i32[index]);
380 index++;
381 factoryPtr->SetYawAngle(metadataItem.data.i32[index]);
382 index++;
383 factoryPtr->SetRollAngle(metadataItem.data.i32[index]);
384 index++;
385 // LCOV_EXCL_STOP
386 }
387
ProcessExternInfo(sptr<MetadataObjectFactory> factoryPtr,const camera_metadata_item_t & metadataItem,int32_t & index,MetadataObjectType typeFromHal,bool isNeedMirror,bool isNeedFlip,RectBoxType type)388 void MetadataCommonUtils::ProcessExternInfo(sptr<MetadataObjectFactory> factoryPtr,
389 const camera_metadata_item_t &metadataItem, int32_t &index,
390 MetadataObjectType typeFromHal, bool isNeedMirror, bool isNeedFlip, RectBoxType type)
391 {
392 // LCOV_EXCL_START
393 switch (typeFromHal) {
394 case MetadataObjectType::FACE:
395 ProcessHumanFaceDetectInfo(factoryPtr, metadataItem, index, isNeedMirror, isNeedFlip, type);
396 break;
397 case MetadataObjectType::CAT_FACE:
398 ProcessCatFaceDetectInfo(factoryPtr, metadataItem, index, isNeedMirror, isNeedFlip, type);
399 break;
400 case MetadataObjectType::DOG_FACE:
401 ProcessDogFaceDetectInfo(factoryPtr, metadataItem, index, isNeedMirror, isNeedFlip, type);
402 break;
403 default:
404 break;
405 }
406 // LCOV_EXCL_STOP
407 }
408
ProcessCatFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,const camera_metadata_item_t & metadataItem,int32_t & index,bool isNeedMirror,bool isNeedFlip,RectBoxType type)409 void MetadataCommonUtils::ProcessCatFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,
410 const camera_metadata_item_t &metadataItem, int32_t &index,
411 bool isNeedMirror, bool isNeedFlip, RectBoxType type)
412 {
413 // LCOV_EXCL_START
414 int32_t version = metadataItem.data.i32[index++];
415 MEDIA_DEBUG_LOG("isNeedMirror: %{public}d, isNeedFlip: %{public}d, version: %{public}d",
416 isNeedMirror, isNeedFlip, version);
417 const int32_t rectLength = 4;
418 const int32_t offsetOne = 1;
419 const int32_t offsetTwo = 2;
420 const int32_t offsetThree = 3;
421 factoryPtr->SetLeftEyeBoundingBox(ProcessRectBox(
422 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
423 metadataItem.data.i32[index + offsetTwo],
424 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
425 index += rectLength;
426 factoryPtr->SetRightEyeBoundingBoxd(ProcessRectBox(
427 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
428 metadataItem.data.i32[index + offsetTwo],
429 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
430 index += rectLength;
431 // LCOV_EXCL_STOP
432 }
433
ProcessDogFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,const camera_metadata_item_t & metadataItem,int32_t & index,bool isNeedMirror,bool isNeedFlip,RectBoxType type)434 void MetadataCommonUtils::ProcessDogFaceDetectInfo(sptr<MetadataObjectFactory> factoryPtr,
435 const camera_metadata_item_t &metadataItem, int32_t &index,
436 bool isNeedMirror, bool isNeedFlip, RectBoxType type)
437 {
438 // LCOV_EXCL_START
439 int32_t version = metadataItem.data.i32[index++];
440 MEDIA_DEBUG_LOG("isNeedMirror: %{public}d, isNeedFlip: %{public}d, version: %{public}d",
441 isNeedMirror, isNeedFlip, version);
442 const int32_t rectLength = 4;
443 const int32_t offsetOne = 1;
444 const int32_t offsetTwo = 2;
445 const int32_t offsetThree = 3;
446 factoryPtr->SetLeftEyeBoundingBox(ProcessRectBox(
447 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
448 metadataItem.data.i32[index + offsetTwo],
449 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
450 index += rectLength;
451 factoryPtr->SetRightEyeBoundingBoxd(ProcessRectBox(
452 metadataItem.data.i32[index], metadataItem.data.i32[index + offsetOne],
453 metadataItem.data.i32[index + offsetTwo],
454 metadataItem.data.i32[index + offsetThree], isNeedMirror, isNeedFlip, type));
455 index += rectLength;
456 // LCOV_EXCL_STOP
457 }
458
ProcessRectBox(int32_t offsetTopLeftX,int32_t offsetTopLeftY,int32_t offsetBottomRightX,int32_t offsetBottomRightY,bool isNeedMirror,bool isNeedFlip,RectBoxType type)459 Rect MetadataCommonUtils::ProcessRectBox(int32_t offsetTopLeftX, int32_t offsetTopLeftY,
460 int32_t offsetBottomRightX, int32_t offsetBottomRightY, bool isNeedMirror, bool isNeedFlip, RectBoxType type)
461 {
462 if (type == RectBoxType::RECT_MECH) {
463 return ProcessMechRectBox(offsetTopLeftX, offsetTopLeftY, offsetBottomRightX, offsetBottomRightY);
464 }
465 return ProcessCameraRectBox(offsetTopLeftX, offsetTopLeftY, offsetBottomRightX, offsetBottomRightY,
466 isNeedMirror, isNeedFlip);
467 }
468
ProcessCameraRectBox(int32_t offsetTopLeftX,int32_t offsetTopLeftY,int32_t offsetBottomRightX,int32_t offsetBottomRightY,bool isNeedMirror,bool isNeedFlip)469 Rect MetadataCommonUtils::ProcessCameraRectBox(int32_t offsetTopLeftX, int32_t offsetTopLeftY,
470 int32_t offsetBottomRightX, int32_t offsetBottomRightY, bool isNeedMirror, bool isNeedFlip)
471 {
472 constexpr int32_t scale = 1000000;
473 double topLeftX = 0;
474 double topLeftY = 0;
475 double width = 0;
476 double height = 0;
477 if (isNeedMirror) {
478 topLeftX = scale - offsetBottomRightY;
479 topLeftY = scale - offsetBottomRightX;
480 width = offsetBottomRightY - offsetTopLeftY;
481 height = offsetBottomRightX - offsetTopLeftX;
482 } else if (isNeedFlip) {
483 topLeftX = offsetTopLeftY;
484 topLeftY = offsetTopLeftX;
485 width = offsetBottomRightY - offsetTopLeftY;
486 height = offsetBottomRightX - offsetTopLeftX;
487 } else {
488 topLeftX = scale - offsetBottomRightY;
489 topLeftY = offsetTopLeftX;
490 width = offsetBottomRightY - offsetTopLeftY;
491 height = offsetBottomRightX - offsetTopLeftX;
492 }
493 topLeftX = topLeftX < 0 ? 0 : topLeftX;
494 topLeftX = topLeftX > scale ? scale : topLeftX;
495 topLeftY = topLeftY < 0 ? 0 : topLeftY;
496 topLeftY = topLeftY > scale ? scale : topLeftY;
497
498 return (Rect){ topLeftX / scale, topLeftY / scale, width / scale, height / scale};
499 }
500
ProcessMechRectBox(int32_t offsetTopLeftX,int32_t offsetTopLeftY,int32_t offsetBottomRightX,int32_t offsetBottomRightY)501 Rect MetadataCommonUtils::ProcessMechRectBox(int32_t offsetTopLeftX, int32_t offsetTopLeftY,
502 int32_t offsetBottomRightX, int32_t offsetBottomRightY)
503 {
504 constexpr int32_t scale = 1000000;
505 double topLeftX = static_cast<double>(offsetTopLeftX);
506 double topLeftY = static_cast<double>(offsetTopLeftY);
507 double width = static_cast<double>(offsetBottomRightX);
508 double height = static_cast<double>(offsetBottomRightY);
509
510 return (Rect){ topLeftX / scale, topLeftY / scale, width / scale, height / scale};
511 }
512
ParsePhysicalApertureRangeByMode(const camera_metadata_item_t & item,const int32_t modeName)513 std::vector<float> ParsePhysicalApertureRangeByMode(const camera_metadata_item_t &item, const int32_t modeName)
514 {
515 const float factor = 20.0;
516 std::vector<float> allRange = {};
517 for (uint32_t i = 0; i < item.count; i++) {
518 allRange.push_back(item.data.f[i] * factor);
519 }
520 MEDIA_DEBUG_LOG("ParsePhysicalApertureRangeByMode allRange=%{public}s",
521 Container2String(allRange.begin(), allRange.end()).c_str());
522 float npos = -1.0;
523 std::vector<std::vector<float>> modeRanges = {};
524 std::vector<float> modeRange = {};
525 for (uint32_t i = 0; i < item.count - 1; i++) {
526 if (item.data.f[i] == npos && item.data.f[i + 1] == npos) {
527 modeRange.emplace_back(npos);
528 MEDIA_DEBUG_LOG("ParsePhysicalApertureRangeByMode mode %{public}d, modeRange=%{public}s",
529 modeName, Container2String(modeRange.begin(), modeRange.end()).c_str());
530 modeRanges.emplace_back(std::move(modeRange));
531 modeRange.clear();
532 i++;
533 continue;
534 }
535 modeRange.emplace_back(item.data.f[i]);
536 }
537 float currentMode = static_cast<float>(modeName);
538 auto it = std::find_if(modeRanges.begin(), modeRanges.end(),
539 [currentMode](auto value) -> bool {
540 return currentMode == value[0];
541 });
542 CHECK_RETURN_RET_ELOG(it == modeRanges.end(), {},
543 "ParsePhysicalApertureRangeByMode Failed meta not support mode:%{public}d", modeName);
544
545 return *it;
546 }
547
548 } // namespace CameraStandard
549 } // namespace OHOS
550