1 /*
2  * Copyright (c) 2021-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_utils.h"
17 #include <securec.h>
18 #include "metadata_log.h"
19 
20 #define IF_COND_PRINT_MSG_AND_RETURN(cond, msg) \
21 if (cond) { \
22     METADATA_ERR_LOG(msg); \
23     return {}; \
24 }
25 
26 namespace OHOS::Camera {
WriteMetadataDataToVec(const camera_metadata_item_t & entry,std::vector<uint8_t> & cameraAbility)27 void MetadataUtils::WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector<uint8_t>& cameraAbility)
28 {
29     if (entry.data_type == META_TYPE_BYTE) {
30         for (size_t i = 0; i < entry.count; i++) {
31             WriteData<int8_t>(*(entry.data.u8 + i), cameraAbility);
32         }
33     } else if (entry.data_type == META_TYPE_INT32) {
34         for (size_t i = 0; i < entry.count; i++) {
35             WriteData<int32_t>(*(entry.data.i32 + i), cameraAbility);
36         }
37     } else if (entry.data_type == META_TYPE_UINT32) {
38         for (size_t i = 0; i < entry.count; i++) {
39             WriteData<uint32_t>(*(entry.data.ui32 + i), cameraAbility);
40         }
41     } else if (entry.data_type == META_TYPE_FLOAT) {
42         for (size_t i = 0; i < entry.count; i++) {
43             WriteData<float>(*(entry.data.f + i), cameraAbility);
44         }
45     } else if (entry.data_type == META_TYPE_INT64) {
46         for (size_t i = 0; i < entry.count; i++) {
47             WriteData<int64_t>(*(entry.data.i64 + i), cameraAbility);
48         }
49     } else if (entry.data_type == META_TYPE_DOUBLE) {
50         for (size_t i = 0; i < entry.count; i++) {
51             WriteData<double>(*(entry.data.d + i), cameraAbility);
52         }
53     } else if (entry.data_type == META_TYPE_RATIONAL) {
54         for (size_t i = 0; i < entry.count; i++) {
55             WriteData<int32_t>((*(entry.data.r + i)).numerator, cameraAbility);
56             WriteData<int32_t>((*(entry.data.r + i)).denominator, cameraAbility);
57         }
58     }
59 }
60 
ConvertMetadataToVec(const std::shared_ptr<CameraMetadata> & metadata,std::vector<uint8_t> & cameraAbility)61 bool MetadataUtils::ConvertMetadataToVec(const std::shared_ptr<CameraMetadata> &metadata,
62     std::vector<uint8_t>& cameraAbility)
63 {
64     cameraAbility.clear();
65 
66     if (metadata == nullptr) {
67         METADATA_ERR_LOG("ConvertMetadataToVec metadata is null!");
68         return false;
69     }
70 
71     common_metadata_header_t *meta = metadata->get();
72     if (meta == nullptr) {
73         WriteData<uint32_t>(0, cameraAbility);
74         METADATA_WARNING_LOG("ConvertMetadataToVec tagCount is 0!");
75         return true;
76     }
77 
78     uint32_t tagCount = GetCameraMetadataItemCount(meta);
79     if (tagCount > MAX_SUPPORTED_TAGS) {
80         METADATA_ERR_LOG("ConvertMetadataToVec tagCount out of range:%{public}d", tagCount);
81         return false;
82     }
83 
84     uint32_t itemCapacity = GetCameraMetadataItemCapacity(meta);
85     if (itemCapacity > MAX_ITEM_CAPACITY) {
86         METADATA_ERR_LOG("ConvertMetadataToVec itemCapacity out of range:%{public}d", itemCapacity);
87         return false;
88     }
89 
90     uint32_t dataCapacity = GetCameraMetadataDataSize(meta);
91     if (dataCapacity > MAX_DATA_CAPACITY) {
92         METADATA_ERR_LOG("ConvertMetadataToVec dataCapacity out of range:%{public}d", dataCapacity);
93         return false;
94     }
95 
96     WriteData<uint32_t>(tagCount, cameraAbility);
97     WriteData<uint32_t>(itemCapacity, cameraAbility);
98     WriteData<uint32_t>(dataCapacity, cameraAbility);
99     for (uint32_t i = 0; i < tagCount; i++) {
100         camera_metadata_item_t item;
101         int ret = GetCameraMetadataItem(meta, i, &item);
102         if (ret != CAM_META_SUCCESS) {
103             METADATA_ERR_LOG("ConvertMetadataToVec get meta item failed!");
104             return false;
105         }
106         WriteData<uint32_t>(item.index, cameraAbility);
107         WriteData<uint32_t>(item.item, cameraAbility);
108         WriteData<uint32_t>(item.data_type, cameraAbility);
109         WriteData<uint32_t>(item.count, cameraAbility);
110         if (item.count > MAX_SUPPORTED_ITEMS) {
111             METADATA_ERR_LOG("ConvertMetadataToVec item.count out of range:%{public}d item:%{public}d",
112                 item.count, item.item);
113             return false;
114         }
115         WriteMetadataDataToVec(item, cameraAbility);
116     }
117     return true;
118 }
119 
EncodeCameraMetadata(const std::shared_ptr<CameraMetadata> & metadata,MessageParcel & data)120 bool MetadataUtils::EncodeCameraMetadata(const std::shared_ptr<CameraMetadata> &metadata,
121                                          MessageParcel &data)
122 {
123     if (metadata == nullptr) {
124         return false;
125     }
126 
127     bool bRet = true;
128     uint32_t tagCount = 0;
129     common_metadata_header_t *meta = metadata->get();
130     if (meta != nullptr) {
131         tagCount = GetCameraMetadataItemCount(meta);
132         bRet = bRet && data.WriteUint32(tagCount);
133         bRet = bRet && data.WriteUint32(GetCameraMetadataItemCapacity(meta));
134         bRet = bRet && data.WriteUint32(GetCameraMetadataDataSize(meta));
135         for (uint32_t i = 0; i < tagCount; i++) {
136             camera_metadata_item_t item;
137             int ret = GetCameraMetadataItem(meta, i, &item);
138             if (ret != CAM_META_SUCCESS) {
139                 return false;
140             }
141 
142             bRet = bRet && data.WriteUint32(item.index);
143             bRet = bRet && data.WriteUint32(item.item);
144             bRet = bRet && data.WriteUint32(item.data_type);
145             bRet = bRet && data.WriteUint32(item.count);
146             bRet = bRet && MetadataUtils::WriteMetadata(item, data);
147         }
148     } else {
149         bRet = data.WriteUint32(tagCount);
150     }
151     return bRet;
152 }
153 
ReadMetadataDataFromVecUInt8(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)154 static void ReadMetadataDataFromVecUInt8(int32_t &index, camera_metadata_item_t &entry,
155     const std::vector<uint8_t>& cameraAbility)
156 {
157     entry.data.u8 = new(std::nothrow) uint8_t[entry.count];
158     if (entry.data.u8 != nullptr) {
159         for (size_t i = 0; i < entry.count; i++) {
160             MetadataUtils::ReadData<uint8_t>(entry.data.u8[i], index, cameraAbility);
161         }
162     }
163 }
164 
ReadMetadataDataFromVecInt32(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)165 static void ReadMetadataDataFromVecInt32(int32_t &index, camera_metadata_item_t &entry,
166     const std::vector<uint8_t>& cameraAbility)
167 {
168     entry.data.i32 = new(std::nothrow) int32_t[entry.count];
169     if (entry.data.i32 != nullptr) {
170         for (size_t i = 0; i < entry.count; i++) {
171             MetadataUtils::ReadData<int32_t>(entry.data.i32[i], index, cameraAbility);
172         }
173     }
174 }
175 
ReadMetadataDataFromVecUInt32(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)176 static void ReadMetadataDataFromVecUInt32(int32_t &index, camera_metadata_item_t &entry,
177     const std::vector<uint8_t>& cameraAbility)
178 {
179     entry.data.ui32 = new(std::nothrow) uint32_t[entry.count];
180     if (entry.data.ui32 != nullptr) {
181         for (size_t i = 0; i < entry.count; i++) {
182             MetadataUtils::ReadData<uint32_t>(entry.data.ui32[i], index, cameraAbility);
183         }
184     }
185 }
186 
ReadMetadataDataFromVecFloat(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)187 static void ReadMetadataDataFromVecFloat(int32_t &index, camera_metadata_item_t &entry,
188     const std::vector<uint8_t>& cameraAbility)
189 {
190     entry.data.f = new(std::nothrow) float[entry.count];
191     if (entry.data.f != nullptr) {
192         for (size_t i = 0; i < entry.count; i++) {
193             MetadataUtils::ReadData<float>(entry.data.f[i], index, cameraAbility);
194         }
195     }
196 }
197 
ReadMetadataDataFromVecInt64(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)198 static void ReadMetadataDataFromVecInt64(int32_t &index, camera_metadata_item_t &entry,
199     const std::vector<uint8_t>& cameraAbility)
200 {
201     entry.data.i64 = new(std::nothrow) int64_t[entry.count];
202     if (entry.data.i64 != nullptr) {
203         for (size_t i = 0; i < entry.count; i++) {
204             MetadataUtils::ReadData<int64_t>(entry.data.i64[i], index, cameraAbility);
205         }
206     }
207 }
208 
ReadMetadataDataFromVecDouble(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)209 static void ReadMetadataDataFromVecDouble(int32_t &index, camera_metadata_item_t &entry,
210     const std::vector<uint8_t>& cameraAbility)
211 {
212     entry.data.d = new(std::nothrow) double[entry.count];
213     if (entry.data.d != nullptr) {
214         for (size_t i = 0; i < entry.count; i++) {
215             MetadataUtils::ReadData<double>(entry.data.d[i], index, cameraAbility);
216         }
217     }
218 }
219 
ReadMetadataDataFromVecRational(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)220 static void ReadMetadataDataFromVecRational(int32_t &index, camera_metadata_item_t &entry,
221     const std::vector<uint8_t>& cameraAbility)
222 {
223     entry.data.r = new(std::nothrow) camera_rational_t[entry.count];
224     if (entry.data.r != nullptr) {
225         for (size_t i = 0; i < entry.count; i++) {
226             MetadataUtils::ReadData<int32_t>(entry.data.r[i].numerator, index, cameraAbility);
227             MetadataUtils::ReadData<int32_t>(entry.data.r[i].denominator, index, cameraAbility);
228         }
229     }
230 }
231 
ReadMetadataDataFromVec(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)232 void MetadataUtils::ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry,
233     const std::vector<uint8_t>& cameraAbility)
234 {
235     switch (entry.data_type) {
236         case META_TYPE_BYTE:
237             ReadMetadataDataFromVecUInt8(index, entry, cameraAbility);
238             break;
239         case META_TYPE_INT32:
240             ReadMetadataDataFromVecInt32(index, entry, cameraAbility);
241             break;
242         case META_TYPE_UINT32:
243             ReadMetadataDataFromVecUInt32(index, entry, cameraAbility);
244             break;
245         case META_TYPE_FLOAT:
246             ReadMetadataDataFromVecFloat(index, entry, cameraAbility);
247             break;
248         case META_TYPE_INT64:
249             ReadMetadataDataFromVecInt64(index, entry, cameraAbility);
250             break;
251         case META_TYPE_DOUBLE:
252             ReadMetadataDataFromVecDouble(index, entry, cameraAbility);
253             break;
254         case META_TYPE_RATIONAL:
255             ReadMetadataDataFromVecRational(index, entry, cameraAbility);
256             break;
257     }
258 }
259 
ConvertVecToMetadata(const std::vector<uint8_t> & cameraAbility,std::shared_ptr<CameraMetadata> & metadata)260 void MetadataUtils::ConvertVecToMetadata(const std::vector<uint8_t>& cameraAbility,
261     std::shared_ptr<CameraMetadata> &metadata)
262 {
263     int32_t index = 0;
264     uint32_t tagCount = 0;
265     uint32_t itemCapacity = 0;
266     uint32_t dataCapacity = 0;
267 
268     if (cameraAbility.size() < MIN_VEC_SIZE) {
269         METADATA_ERR_LOG("ConvertVecToMetadata cameraAbility size:%{public}d", static_cast<int>(cameraAbility.size()));
270         return;
271     }
272     ReadData<uint32_t>(tagCount, index, cameraAbility);
273     if (tagCount > MAX_SUPPORTED_TAGS) {
274         METADATA_ERR_LOG("ConvertVecToMetadata tagCount out of range:%{public}d", tagCount);
275         return;
276     }
277     ReadData<uint32_t>(itemCapacity, index, cameraAbility);
278     if (itemCapacity > MAX_ITEM_CAPACITY) {
279         METADATA_ERR_LOG("ConvertVecToMetadata itemCapacity out of range:%{public}d", itemCapacity);
280         return;
281     }
282     ReadData<uint32_t>(dataCapacity, index, cameraAbility);
283     if (dataCapacity > MAX_DATA_CAPACITY) {
284         METADATA_ERR_LOG("ConvertVecToMetadata dataCapacity out of range:%{public}d", dataCapacity);
285         return;
286     }
287 
288     std::vector<camera_metadata_item_t> items;
289     for (uint32_t i = 0; i < tagCount; i++) {
290         camera_metadata_item_t item;
291         ReadData<uint32_t>(item.index, index, cameraAbility);
292         ReadData<uint32_t>(item.item, index, cameraAbility);
293         ReadData<uint32_t>(item.data_type, index, cameraAbility);
294         ReadData<uint32_t>(item.count, index, cameraAbility);
295         if (item.count > MAX_SUPPORTED_ITEMS) {
296             METADATA_ERR_LOG("ConvertVecToMetadata item.count out of range:%{public}d item:%{public}d",
297                 item.count, item.item);
298             return;
299         }
300         ReadMetadataDataFromVec(index, item, cameraAbility);
301         items.push_back(item);
302     }
303 
304     metadata = std::make_shared<CameraMetadata>(itemCapacity, dataCapacity);
305     common_metadata_header_t *meta = metadata->get();
306     for (auto &item_ : items) {
307         void *buffer = nullptr;
308         MetadataUtils::ItemDataToBuffer(item_, &buffer);
309         (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count);
310         FreeMetadataBuffer(item_);
311     }
312 }
313 
DecodeCameraMetadata(MessageParcel & data,std::shared_ptr<CameraMetadata> & metadata)314 void MetadataUtils::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr<CameraMetadata> &metadata)
315 {
316     uint32_t tagCount = data.ReadUint32();
317     uint32_t itemCapacity = data.ReadUint32();
318     uint32_t dataCapacity = data.ReadUint32();
319 
320     if (tagCount > MAX_SUPPORTED_TAGS) {
321         tagCount = MAX_SUPPORTED_TAGS;
322         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value");
323     }
324 
325     if (itemCapacity > MAX_ITEM_CAPACITY) {
326         itemCapacity = MAX_ITEM_CAPACITY;
327         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value");
328     }
329 
330     if (dataCapacity > MAX_DATA_CAPACITY) {
331         dataCapacity = MAX_DATA_CAPACITY;
332         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value");
333     }
334 
335     std::vector<camera_metadata_item_t> items;
336     for (uint32_t i = 0; i < tagCount; i++) {
337         camera_metadata_item_t item;
338         item.index = data.ReadUint32();
339         item.item = data.ReadUint32();
340         item.data_type = data.ReadUint32();
341         item.count = data.ReadUint32();
342         if (item.count > MAX_SUPPORTED_ITEMS) {
343             item.count = MAX_SUPPORTED_ITEMS;
344             METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value");
345         }
346         MetadataUtils::ReadMetadata(item, data);
347         items.push_back(item);
348     }
349 
350     metadata = std::make_shared<CameraMetadata>(itemCapacity, dataCapacity);
351     common_metadata_header_t *meta = metadata->get();
352     for (auto &item_ : items) {
353         void *buffer = nullptr;
354         MetadataUtils::ItemDataToBuffer(item_, &buffer);
355         (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count);
356         FreeMetadataBuffer(item_);
357     }
358 }
359 
WriteMetadata(const camera_metadata_item_t & item,MessageParcel & data)360 bool MetadataUtils::WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data)
361 {
362     bool bRet = false;
363     size_t i;
364     if (item.data_type == META_TYPE_BYTE) {
365         std::vector<uint8_t> byteBuffers;
366         for (i = 0; i < item.count; i++) {
367             byteBuffers.push_back(*(item.data.u8 + i));
368         }
369         bRet = data.WriteUInt8Vector(byteBuffers);
370     } else if (item.data_type == META_TYPE_INT32) {
371         std::vector<int32_t> int32Buffers;
372         for (i = 0; i < item.count; i++) {
373             int32Buffers.push_back(*(item.data.i32 + i));
374         }
375         bRet = data.WriteInt32Vector(int32Buffers);
376     } else if (item.data_type == META_TYPE_FLOAT) {
377         std::vector<float> floatBuffers;
378         for (i = 0; i < item.count; i++) {
379             floatBuffers.push_back(*(item.data.f + i));
380         }
381         bRet = data.WriteFloatVector(floatBuffers);
382     } else if (item.data_type == META_TYPE_UINT32) {
383         std::vector<uint32_t> uInt32Buffers;
384         for (i = 0; i < item.count; i++) {
385             uInt32Buffers.push_back(*(item.data.ui32 + i));
386         }
387         bRet = data.WriteUInt32Vector(uInt32Buffers);
388     } else if (item.data_type == META_TYPE_INT64) {
389         std::vector<int64_t> int64Buffers;
390         for (i = 0; i < item.count; i++) {
391             int64Buffers.push_back(*(item.data.i64 + i));
392         }
393         bRet = data.WriteInt64Vector(int64Buffers);
394     } else if (item.data_type == META_TYPE_DOUBLE) {
395         std::vector<double> doubleBuffers;
396         for (i = 0; i < item.count; i++) {
397             doubleBuffers.push_back(*(item.data.d + i));
398         }
399         bRet = data.WriteDoubleVector(doubleBuffers);
400     } else if (item.data_type == META_TYPE_RATIONAL) {
401         std::vector<int32_t> rationalBuffers;
402         for (i = 0; i < item.count; i++) {
403             rationalBuffers.push_back((*(item.data.r + i)).numerator);
404             rationalBuffers.push_back((*(item.data.r + i)).denominator);
405         }
406         bRet = data.WriteInt32Vector(rationalBuffers);
407     }
408 
409     return bRet;
410 }
411 
EncodeToString(std::shared_ptr<CameraMetadata> metadata)412 std::string MetadataUtils::EncodeToString(std::shared_ptr<CameraMetadata> metadata)
413 {
414     int32_t ret;
415     const int32_t headerLength = sizeof(common_metadata_header_t);
416     const int32_t itemLen = sizeof(camera_metadata_item_entry_t);
417     const int32_t itemFixedLen = static_cast<int32_t>(offsetof(camera_metadata_item_entry_t, data));
418 
419     if (metadata == nullptr || metadata->get() == nullptr) {
420         METADATA_ERR_LOG("MetadataUtils::EncodeToString Metadata is invalid");
421         return {};
422     }
423 
424     common_metadata_header_t *meta = metadata->get();
425     int32_t encodeDataLen = headerLength + (itemLen * meta->item_count) + meta->data_count;
426     std::string s(encodeDataLen, '\0');
427     char *encodeData = &s[0];
428     ret = memcpy_s(encodeData, encodeDataLen, meta, headerLength);
429     if (ret != EOK) {
430         METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for metadata header");
431         return {};
432     }
433     encodeData += headerLength;
434     encodeDataLen -= headerLength;
435     camera_metadata_item_entry_t *item = GetMetadataItems(meta);
436     for (uint32_t index = 0; index < meta->item_count; index++, item++) {
437         ret = memcpy_s(encodeData, encodeDataLen, item, itemFixedLen);
438         if (ret != EOK) {
439             METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item fixed fields");
440             return {};
441         }
442         encodeData += itemFixedLen;
443         encodeDataLen -= itemFixedLen;
444         int32_t dataLen = itemLen - itemFixedLen;
445         ret = memcpy_s(encodeData, encodeDataLen,  &(item->data), dataLen);
446         if (ret != EOK) {
447             METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item data field");
448             return {};
449         }
450         encodeData += dataLen;
451         encodeDataLen -= dataLen;
452     }
453 
454     if (meta->data_count != 0) {
455         ret = copyEncodeToStringMem(meta, encodeData, encodeDataLen);
456         if (ret != CAM_META_SUCCESS) {
457             return {};
458         }
459         encodeData += meta->data_count;
460     }
461     METADATA_DEBUG_LOG("MetadataUtils::EncodeToString Calculated length: %{public}zu, encoded length: %{public}zu",
462                        s.capacity(), (encodeData - &s[0]));
463 
464     return s;
465 }
466 
copyEncodeToStringMem(common_metadata_header_t * meta,char * encodeData,int32_t encodeDataLen)467 int MetadataUtils::copyEncodeToStringMem(common_metadata_header_t *meta, char *encodeData, int32_t encodeDataLen)
468 {
469     uint8_t *metaMetadataData = GetMetadataData(meta);
470     int32_t ret = CAM_META_SUCCESS;
471     if (metaMetadataData == nullptr) {
472         METADATA_ERR_LOG("MetadataUtils::EncodeToString GetMetadataData failed");
473         return CAM_META_FAILURE;
474     }
475     ret = memcpy_s(encodeData, encodeDataLen, metaMetadataData, meta->data_count);
476     if (ret != EOK) {
477         METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for data");
478         return CAM_META_FAILURE;
479     }
480     return CAM_META_SUCCESS;
481 }
482 
DecodeFromString(std::string setting)483 std::shared_ptr<CameraMetadata> MetadataUtils::DecodeFromString(std::string setting)
484 {
485     int32_t ret;
486     uint32_t totalLen = setting.capacity();
487     const uint32_t headerLength = sizeof(common_metadata_header_t);
488     const uint32_t itemLen = sizeof(camera_metadata_item_entry_t);
489     const uint32_t itemFixedLen = offsetof(camera_metadata_item_entry_t, data);
490 
491     IF_COND_PRINT_MSG_AND_RETURN(totalLen < headerLength,
492         "MetadataUtils::DecodeFromString Length is less than metadata header length")
493 
494     char *decodeData = &setting[0];
495     common_metadata_header_t header;
496     ret = memcpy_s(&header, headerLength, decodeData, headerLength);
497 
498     IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
499         "MetadataUtils::DecodeFromString Failed to copy memory for metadata header")
500     std::shared_ptr<CameraMetadata> metadata
501         = std::make_shared<CameraMetadata>(header.item_capacity, header.data_capacity);
502     common_metadata_header_t *meta = metadata->get();
503 
504     IF_COND_PRINT_MSG_AND_RETURN(!meta,
505         "MetadataUtils::DecodeFromString Failed to get metadata header")
506     uint32_t actualMemSize = meta->size;
507     ret = memcpy_s(meta, headerLength, &header, headerLength);
508 
509     IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
510         "MetadataUtils::DecodeFromString Failed to copy memory for metadata header")
511     bool isItemsStartInvalid = meta->items_start >= actualMemSize || meta->items_start < headerLength;
512     bool isDataStartInvalid = meta->data_start >= actualMemSize || meta->data_start < headerLength;
513     bool isMetadataCountInvaild = (actualMemSize - meta->items_start) < (uint64_t)meta->item_count * itemLen ||
514         (actualMemSize - meta->data_start) < meta->data_count;
515     IF_COND_PRINT_MSG_AND_RETURN(isItemsStartInvalid || isDataStartInvalid || isMetadataCountInvaild,
516         "MetadataUtils::DecodeFromString invalid item_start")
517     decodeData += headerLength;
518     camera_metadata_item_entry_t *item = GetMetadataItems(meta);
519     for (uint32_t index = 0; index < meta->item_count; index++, item++) {
520         if (totalLen < ((decodeData - &setting[0]) + itemLen)) {
521             METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed at item index: %{public}u", index);
522             return {};
523         }
524         ret = memcpy_s(item, itemFixedLen, decodeData, itemFixedLen);
525 
526         IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
527             "MetadataUtils::DecodeFromString Failed to copy memory for item fixed fields")
528         decodeData += itemFixedLen;
529         uint32_t dataLen = itemLen - itemFixedLen;
530         ret = memcpy_s(&(item->data), dataLen,  decodeData, dataLen);
531 
532         IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
533             "MetadataUtils::DecodeFromString Failed to copy memory for item data field")
534         decodeData += dataLen;
535     }
536 
537     char *decodeMetadataData = &setting[0];
538     ret = copyDecodeFromStringMem(meta, decodeData, decodeMetadataData, totalLen);
539     if (ret != CAM_META_SUCCESS) {
540         return {};
541     }
542 
543     METADATA_DEBUG_LOG("MetadataUtils::DecodeFromString String length: %{public}zu, Decoded length: %{public}zu",
544                        setting.capacity(), (decodeData - &setting[0]));
545     return metadata;
546 }
547 
copyDecodeFromStringMem(common_metadata_header_t * meta,char * decodeData,char * decodeMetadataData,uint32_t totalLen)548 int MetadataUtils::copyDecodeFromStringMem(common_metadata_header_t *meta, char *decodeData,
549     char *decodeMetadataData, uint32_t totalLen)
550 {
551     if (meta->data_count != 0) {
552         IF_COND_PRINT_MSG_AND_RETURN(
553             totalLen < static_cast<uint32_t>(((decodeData - decodeMetadataData) + meta->data_count)),
554             "MetadataUtils::DecodeFromString Failed at data copy")
555         uint8_t *metaMetadataData = GetMetadataData(meta);
556         int32_t ret;
557         if (metaMetadataData == nullptr) {
558             METADATA_ERR_LOG("MetadataUtils::DecodeFromString GetMetadataData failed");
559             return CAM_META_FAILURE;
560         }
561         ret = memcpy_s(metaMetadataData, meta->data_count, decodeData, meta->data_count);
562 
563         IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
564             "MetadataUtils::DecodeFromString Failed to copy memory for item data field")
565         decodeData += meta->data_count;
566         return CAM_META_SUCCESS;
567     }
568     return CAM_META_SUCCESS;
569 }
570 
ReadMetadataUInt8(camera_metadata_item_t & entry,MessageParcel & data)571 static void ReadMetadataUInt8(camera_metadata_item_t &entry, MessageParcel &data)
572 {
573     std::vector<uint8_t> buffers;
574     data.ReadUInt8Vector(&buffers);
575     entry.data.u8 = new(std::nothrow) uint8_t[entry.count];
576     if (entry.data.u8 != nullptr) {
577         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
578             entry.data.u8[i] = buffers.at(i);
579         }
580     }
581 }
582 
ReadMetadataInt32(camera_metadata_item_t & entry,MessageParcel & data)583 static void ReadMetadataInt32(camera_metadata_item_t &entry, MessageParcel &data)
584 {
585     std::vector<int32_t> buffers;
586     data.ReadInt32Vector(&buffers);
587     entry.data.i32 = new(std::nothrow) int32_t[entry.count];
588     if (entry.data.i32 != nullptr) {
589         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
590             entry.data.i32[i] = buffers.at(i);
591         }
592     }
593 }
594 
ReadMetadataUInt32(camera_metadata_item_t & entry,MessageParcel & data)595 static void ReadMetadataUInt32(camera_metadata_item_t &entry, MessageParcel &data)
596 {
597     std::vector<uint32_t> buffers;
598     data.ReadUInt32Vector(&buffers);
599     entry.data.ui32 = new(std::nothrow) uint32_t[entry.count];
600     if (entry.data.ui32 != nullptr) {
601         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
602             entry.data.ui32[i] = buffers.at(i);
603         }
604     }
605 }
606 
ReadMetadataFloat(camera_metadata_item_t & entry,MessageParcel & data)607 static void ReadMetadataFloat(camera_metadata_item_t &entry, MessageParcel &data)
608 {
609     std::vector<float> buffers;
610     data.ReadFloatVector(&buffers);
611     entry.data.f = new(std::nothrow) float[entry.count];
612     if (entry.data.f != nullptr) {
613         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
614             entry.data.f[i] = buffers.at(i);
615         }
616     }
617 }
618 
ReadMetadataInt64(camera_metadata_item_t & entry,MessageParcel & data)619 static void ReadMetadataInt64(camera_metadata_item_t &entry, MessageParcel &data)
620 {
621     std::vector<int64_t> buffers;
622     data.ReadInt64Vector(&buffers);
623     entry.data.i64 = new(std::nothrow) int64_t[entry.count];
624     if (entry.data.i64 != nullptr) {
625         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
626             entry.data.i64[i] = buffers.at(i);
627         }
628     }
629 }
630 
ReadMetadataDouble(camera_metadata_item_t & entry,MessageParcel & data)631 static void ReadMetadataDouble(camera_metadata_item_t &entry, MessageParcel &data)
632 {
633     std::vector<double> buffers;
634     data.ReadDoubleVector(&buffers);
635     entry.data.d = new(std::nothrow) double[entry.count];
636     if (entry.data.d != nullptr) {
637         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
638             entry.data.d[i] = buffers.at(i);
639         }
640     }
641 }
642 
ReadMetadataRational(camera_metadata_item_t & entry,MessageParcel & data)643 static void ReadMetadataRational(camera_metadata_item_t &entry, MessageParcel &data)
644 {
645     std::vector<int32_t> buffers;
646     data.ReadInt32Vector(&buffers);
647     if (buffers.size() < 1) {
648         METADATA_ERR_LOG("MetadataUtils::ReadMetadataRational the buffers size < 1");
649         entry.data.r = nullptr;
650         return;
651     }
652     entry.data.r = new(std::nothrow) camera_rational_t[entry.count];
653     if (entry.data.r != nullptr) {
654         for (size_t i = 0, j = 0;
655             i < entry.count && j < static_cast<size_t>(buffers.size() - 1);
656             i++, j += 2) { // 2:Take two elements from the buffer vector container
657             entry.data.r[i].numerator = buffers.at(j);
658             entry.data.r[i].denominator = buffers.at(j + 1);
659         }
660     }
661 }
ReadMetadata(camera_metadata_item_t & entry,MessageParcel & data)662 bool MetadataUtils::ReadMetadata(camera_metadata_item_t &entry, MessageParcel &data)
663 {
664     if (entry.count > MAX_SUPPORTED_ITEMS) {
665         entry.count = MAX_SUPPORTED_ITEMS;
666         METADATA_ERR_LOG("MetadataUtils::ReadMetadata item.count is more than supported value");
667     }
668     switch (entry.data_type) {
669         case META_TYPE_BYTE:
670             ReadMetadataUInt8(entry, data);
671             break;
672         case META_TYPE_INT32:
673             ReadMetadataInt32(entry, data);
674             break;
675         case META_TYPE_UINT32:
676             ReadMetadataUInt32(entry, data);
677             break;
678         case META_TYPE_FLOAT:
679             ReadMetadataFloat(entry, data);
680             break;
681         case META_TYPE_INT64:
682             ReadMetadataInt64(entry, data);
683             break;
684         case META_TYPE_DOUBLE:
685             ReadMetadataDouble(entry, data);
686             break;
687         case META_TYPE_RATIONAL:
688             ReadMetadataRational(entry, data);
689             break;
690     }
691     return true;
692 }
693 
ItemDataToBuffer(const camera_metadata_item_t & item,void ** buffer)694 void MetadataUtils::ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer)
695 {
696     if (buffer == nullptr) {
697         METADATA_ERR_LOG("MetadataUtils::ItemDataToBuffer buffer is null");
698         return;
699     }
700     if (item.data_type == META_TYPE_BYTE) {
701         *buffer = reinterpret_cast<void *>(item.data.u8);
702     } else if (item.data_type == META_TYPE_INT32) {
703         *buffer = reinterpret_cast<void *>(item.data.i32);
704     } else if (item.data_type == META_TYPE_FLOAT) {
705         *buffer = reinterpret_cast<void *>(item.data.f);
706     } else if (item.data_type == META_TYPE_UINT32) {
707         *buffer = reinterpret_cast<void *>(item.data.ui32);
708     } else if (item.data_type == META_TYPE_INT64) {
709         *buffer = reinterpret_cast<void *>(item.data.i64);
710     } else if (item.data_type == META_TYPE_DOUBLE) {
711         *buffer = reinterpret_cast<void *>(item.data.d);
712     } else if (item.data_type == META_TYPE_RATIONAL) {
713         *buffer = reinterpret_cast<void *>(item.data.r);
714     }
715 }
716 
FreeMetadataBuffer(camera_metadata_item_t & entry)717 void MetadataUtils::FreeMetadataBuffer(camera_metadata_item_t &entry)
718 {
719     if (entry.data_type == META_TYPE_BYTE) {
720         if (entry.data.u8 != nullptr) {
721             delete[] entry.data.u8;
722         }
723     } else if (entry.data_type == META_TYPE_INT32) {
724         if (entry.data.i32 != nullptr) {
725             delete[] entry.data.i32;
726         }
727     } else if (entry.data_type == META_TYPE_FLOAT) {
728         if (entry.data.f != nullptr) {
729             delete[] entry.data.f;
730         }
731     } else if (entry.data_type == META_TYPE_INT64) {
732         if (entry.data.i64 != nullptr) {
733             delete[] entry.data.i64;
734         }
735     } else if (entry.data_type == META_TYPE_UINT32) {
736         if (entry.data.ui32 != nullptr) {
737             delete[] entry.data.ui32;
738         }
739     } else if (entry.data_type == META_TYPE_DOUBLE) {
740         if (entry.data.d != nullptr) {
741             delete[] entry.data.d;
742         }
743     } else if (entry.data_type == META_TYPE_RATIONAL) {
744         if (entry.data.r != nullptr) {
745             delete[] entry.data.r;
746         }
747     }
748 }
749 } // Camera
750