1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "camera_fwk_metadata_utils.h"
17
18 #include <cstdint>
19 #include <unordered_set>
20
21 #include "camera_log.h"
22 #include "camera_metadata_operator.h"
23 #include "camera_util.h"
24
25 namespace OHOS {
26 namespace CameraStandard {
27 namespace CameraFwkMetadataUtils {
28 namespace {
29
30 constexpr uint32_t ITEM_CAPACITY = 20;
31 constexpr uint32_t DATA_CAPACITY = 200;
32
33 std::vector<uint32_t> reportMetadataTag {
34 OHOS_CONTROL_FLASH_MODE,
35 OHOS_CONTROL_FLASH_STATE,
36 OHOS_CONTROL_FOCUS_MODE,
37 OHOS_CONTROL_QUALITY_PRIORITIZATION,
38 OHOS_CONTROL_FOCUS_STATE,
39 OHOS_STATISTICS_FACE_RECTANGLES,
40 OHOS_CAMERA_MACRO_STATUS
41 };
42
ForEach(uint32_t iteratorCount,std::function<void (uint32_t)> fun)43 void ForEach(uint32_t iteratorCount, std::function<void(uint32_t)> fun)
44 {
45 for (uint32_t index = 0; index < iteratorCount; index++) {
46 fun(index);
47 }
48 }
49 } // namespace
50
CheckSysMeta(uint32_t item)51 bool CheckSysMeta(uint32_t item)
52 {
53 static const std::unordered_set<uint32_t> sysTags = {
54 OHOS_CONTROL_PREPARE_ZOOM,
55 OHOS_CONTROL_BEAUTY_TYPE,
56 OHOS_CONTROL_FOCUS_RANGE_TYPE,
57 OHOS_CONTROL_FOCUS_DRIVEN_TYPE,
58 OHOS_CONTROL_COLOR_RESERVATION_TYPE,
59 OHOS_CONTROL_CAMERA_PORTRAIT_THEME_TYPE,
60 };
61 return sysTags.find(item) != sysTags.end();
62 }
63
MergeMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata,std::shared_ptr<OHOS::Camera::CameraMetadata> dstMetadata)64 bool MergeMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata,
65 std::shared_ptr<OHOS::Camera::CameraMetadata> dstMetadata)
66 {
67 bool isSysCall = CheckSystemApp();
68 CHECK_RETURN_RET(srcMetadata == nullptr || dstMetadata == nullptr, false);
69 auto srcHeader = srcMetadata->get();
70 CHECK_RETURN_RET(srcHeader == nullptr, false);
71 auto dstHeader = dstMetadata->get();
72 CHECK_RETURN_RET(dstHeader == nullptr, false);
73 auto srcItemCount = srcHeader->item_count;
74 camera_metadata_item_t srcItem;
75 for (uint32_t index = 0; index < srcItemCount; index++) {
76 int ret = OHOS::Camera::GetCameraMetadataItem(srcHeader, index, &srcItem);
77 CHECK_RETURN_RET_ELOG(ret != CAM_META_SUCCESS, false,
78 "Failed to get metadata item at index: %{public}d", index);
79 bool status = false;
80 uint32_t currentIndex;
81 MEDIA_DEBUG_LOG("MergeMetadata src item:%{public}d", srcItem.item);
82 if (!isSysCall) {
83 CHECK_EXECUTE(CheckSysMeta(srcItem.item), continue);
84 }
85 MEDIA_DEBUG_LOG("MergeMetadata update item:%{public}d", srcItem.item);
86 ret = OHOS::Camera::FindCameraMetadataItemIndex(dstMetadata->get(), srcItem.item, ¤tIndex);
87 if (ret == CAM_META_ITEM_NOT_FOUND) {
88 status = dstMetadata->addEntry(srcItem.item, srcItem.data.u8, srcItem.count);
89 } else if (ret == CAM_META_SUCCESS) {
90 status = dstMetadata->updateEntry(srcItem.item, srcItem.data.u8, srcItem.count);
91 }
92 CHECK_RETURN_RET_ELOG(!status, false, "Failed to update metadata item: %{public}d", srcItem.item);
93 }
94 return true;
95 }
96
CopyMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)97 std::shared_ptr<OHOS::Camera::CameraMetadata> CopyMetadata(
98 const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)
99 {
100 CHECK_RETURN_RET_ELOG(srcMetadata == nullptr, nullptr, "CopyMetadata fail, src is null");
101 auto metadataHeader = srcMetadata->get();
102 auto newMetadata =
103 std::make_shared<OHOS::Camera::CameraMetadata>(metadataHeader->item_capacity, metadataHeader->data_capacity);
104 MergeMetadata(srcMetadata, newMetadata);
105 return newMetadata;
106 }
107
UpdateMetadataTag(const camera_metadata_item_t & srcItem,std::shared_ptr<OHOS::Camera::CameraMetadata> dstMetadata)108 bool UpdateMetadataTag(const camera_metadata_item_t& srcItem, std::shared_ptr<OHOS::Camera::CameraMetadata> dstMetadata)
109 {
110 CHECK_RETURN_RET_ELOG(dstMetadata == nullptr, false, "UpdateMetadataTag fail, dstMetadata is null");
111 uint32_t itemIndex;
112 int32_t result = OHOS::Camera::FindCameraMetadataItemIndex(dstMetadata->get(), srcItem.item, &itemIndex);
113 bool status = false;
114 if (result == CAM_META_ITEM_NOT_FOUND) {
115 status = dstMetadata->addEntry(srcItem.item, srcItem.data.u8, srcItem.count);
116 } else if (result == CAM_META_SUCCESS) {
117 status = dstMetadata->updateEntry(srcItem.item, srcItem.data.u8, srcItem.count);
118 }
119 CHECK_RETURN_RET_ELOG(!status, false, "UpdateMetadataTag fail, err is %{public}d", result);
120 return true;
121 }
122
DumpMetadataInfo(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)123 void DumpMetadataInfo(const std::shared_ptr<OHOS::Camera::CameraMetadata> srcMetadata)
124 {
125 CHECK_RETURN_ELOG(srcMetadata == nullptr, "DumpMetadataInfo srcMetadata is null");
126 auto metadataHeader = srcMetadata->get();
127 uint32_t version = metadataHeader->version;
128 uint32_t itemCount = metadataHeader->item_count;
129 uint32_t dataCount = metadataHeader->data_count;
130 uint32_t size = metadataHeader->size;
131 MEDIA_DEBUG_LOG("DumpMetadataInfo srcMetadata \
132 version:%{public}d, itemCount:%{public}d, dataCount:%{public}d, size:%{public}d",
133 version, itemCount, dataCount, size);
134
135 for (uint32_t i = 0; i < itemCount; i++) {
136 camera_metadata_item_t item;
137 Camera::GetCameraMetadataItem(metadataHeader, i, &item);
138 DumpMetadataItemInfo(item);
139 }
140 }
141
DumpMetadataItemInfo(const camera_metadata_item_t & metadataItem)142 void DumpMetadataItemInfo(const camera_metadata_item_t& metadataItem)
143 {
144 uint32_t dataType = metadataItem.data_type;
145 uint32_t dataCount = metadataItem.count;
146 const char* tagName = Camera::GetCameraMetadataItemName(metadataItem.item);
147 MEDIA_DEBUG_LOG("DumpMetadataItemInfo \
148 tag:%{public}d->%{public}s, dataType:%{public}d, dataCount:%{public}d",
149 metadataItem.item, tagName, dataType, dataCount);
150 if (dataType == META_TYPE_BYTE) {
151 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
152 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}d",
153 metadataItem.item, tagName, index, metadataItem.data.u8[index]);
154 });
155 } else if (dataType == META_TYPE_INT32) {
156 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
157 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}d",
158 metadataItem.item, tagName, index, metadataItem.data.i32[index]);
159 });
160 } else if (dataType == META_TYPE_UINT32) {
161 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
162 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}d",
163 metadataItem.item, tagName, index, metadataItem.data.ui32[index]);
164 });
165 } else if (dataType == META_TYPE_FLOAT) {
166 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
167 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}f",
168 metadataItem.item, tagName, index, metadataItem.data.f[index]);
169 });
170 } else if (dataType == META_TYPE_INT64) {
171 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
172 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}lld",
173 metadataItem.item, tagName, index, static_cast<long long>(metadataItem.data.i64[index]));
174 });
175 } else if (dataType == META_TYPE_DOUBLE) {
176 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
177 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, value:%{public}lf",
178 metadataItem.item, tagName, index, metadataItem.data.d[index]);
179 });
180 } else if (dataType == META_TYPE_RATIONAL) {
181 ForEach(dataCount, [&metadataItem, &tagName](uint32_t index) {
182 MEDIA_DEBUG_LOG("DumpMetadataItemInfo:%{public}d->%{public}s, dataIndex:%{public}d, numerator:%{public}d, "
183 "denominator:%{public}d",
184 metadataItem.item, tagName, index, metadataItem.data.r[index].numerator,
185 metadataItem.data.r[index].denominator);
186 });
187 } else {
188 MEDIA_WARNING_LOG("DumpMetadataItemInfo get unknown dataType:%{public}d", dataType);
189 }
190 }
191
RecreateMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)192 std::shared_ptr<OHOS::Camera::CameraMetadata> RecreateMetadata(
193 const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
194 {
195 CHECK_RETURN_RET_ELOG(metadata == nullptr, nullptr, "RecreateMetadata is fail, metadata is null");
196 common_metadata_header_t* header = metadata->get();
197 std::shared_ptr<OHOS::Camera::CameraMetadata> newMetadata =
198 std::make_shared<OHOS::Camera::CameraMetadata>(ITEM_CAPACITY, DATA_CAPACITY);
199
200 for (uint32_t metadataTag : reportMetadataTag) {
201 camera_metadata_item_t item;
202 int ret = Camera::FindCameraMetadataItem(header, metadataTag, &item);
203 if (ret == 0 && item.count != 0) {
204 newMetadata->addEntry(item.item, item.data.u8, item.count);
205 }
206 }
207 return newMetadata;
208 }
209
LogFormatCameraMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)210 void LogFormatCameraMetadata(const std::shared_ptr<OHOS::Camera::CameraMetadata> metadata)
211 {
212 CHECK_RETURN_ELOG(metadata == nullptr, "LogFormatCameraMetadata: Metadata pointer is null");
213
214 auto header = metadata->get();
215 CHECK_RETURN_ELOG(header == nullptr, "LogFormatCameraMetadata: Metadata header is null");
216
217 std::string metaStr = OHOS::Camera::FormatCameraMetadataToString(header);
218 MEDIA_DEBUG_LOG("LogFormatCameraMetadata: metaStr %{public}s", metaStr.c_str());
219 }
220 } // namespace CameraFwkMetadataUtils
221 } // namespace CameraStandard
222 } // namespace OHOS