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) \
21if (cond) { \
22    METADATA_ERR_LOG(msg); \
23    return {}; \
24}
25
26namespace OHOS::Camera {
27void 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
61bool 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
120bool 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
154static 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
165static 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
176static 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
187static 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
198static 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
209static 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
220static 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
232void 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
260void 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    ReadData<uint32_t>(tagCount, index, cameraAbility);
269    if (tagCount > MAX_SUPPORTED_TAGS) {
270        METADATA_ERR_LOG("ConvertVecToMetadata tagCount out of range:%{public}d", tagCount);
271        return;
272    }
273    ReadData<uint32_t>(itemCapacity, index, cameraAbility);
274    if (itemCapacity > MAX_ITEM_CAPACITY) {
275        METADATA_ERR_LOG("ConvertVecToMetadata itemCapacity out of range:%{public}d", itemCapacity);
276        return;
277    }
278    ReadData<uint32_t>(dataCapacity, index, cameraAbility);
279    if (dataCapacity > MAX_DATA_CAPACITY) {
280        METADATA_ERR_LOG("ConvertVecToMetadata dataCapacity out of range:%{public}d", dataCapacity);
281        return;
282    }
283
284    std::vector<camera_metadata_item_t> items;
285    for (uint32_t i = 0; i < tagCount; i++) {
286        camera_metadata_item_t item;
287        ReadData<uint32_t>(item.index, index, cameraAbility);
288        ReadData<uint32_t>(item.item, index, cameraAbility);
289        ReadData<uint32_t>(item.data_type, index, cameraAbility);
290        ReadData<uint32_t>(item.count, index, cameraAbility);
291        if (item.count > MAX_SUPPORTED_ITEMS) {
292            METADATA_ERR_LOG("ConvertVecToMetadata item.count out of range:%{public}d item:%{public}d",
293                item.count, item.item);
294            return;
295        }
296        ReadMetadataDataFromVec(index, item, cameraAbility);
297        items.push_back(item);
298    }
299
300    metadata = std::make_shared<CameraMetadata>(itemCapacity, dataCapacity);
301    common_metadata_header_t *meta = metadata->get();
302    for (auto &item_ : items) {
303        void *buffer = nullptr;
304        MetadataUtils::ItemDataToBuffer(item_, &buffer);
305        (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count);
306        FreeMetadataBuffer(item_);
307    }
308}
309
310void MetadataUtils::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr<CameraMetadata> &metadata)
311{
312    uint32_t tagCount = data.ReadUint32();
313    uint32_t itemCapacity = data.ReadUint32();
314    uint32_t dataCapacity = data.ReadUint32();
315
316    if (tagCount > MAX_SUPPORTED_TAGS) {
317        tagCount = MAX_SUPPORTED_TAGS;
318        METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value");
319    }
320
321    if (itemCapacity > MAX_ITEM_CAPACITY) {
322        itemCapacity = MAX_ITEM_CAPACITY;
323        METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value");
324    }
325
326    if (dataCapacity > MAX_DATA_CAPACITY) {
327        dataCapacity = MAX_DATA_CAPACITY;
328        METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value");
329    }
330
331    std::vector<camera_metadata_item_t> items;
332    for (uint32_t i = 0; i < tagCount; i++) {
333        camera_metadata_item_t item;
334        item.index = data.ReadUint32();
335        item.item = data.ReadUint32();
336        item.data_type = data.ReadUint32();
337        item.count = data.ReadUint32();
338        if (item.count > MAX_SUPPORTED_ITEMS) {
339            item.count = MAX_SUPPORTED_ITEMS;
340            METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value");
341        }
342        MetadataUtils::ReadMetadata(item, data);
343        items.push_back(item);
344    }
345
346    metadata = std::make_shared<CameraMetadata>(itemCapacity, dataCapacity);
347    common_metadata_header_t *meta = metadata->get();
348    for (auto &item_ : items) {
349        void *buffer = nullptr;
350        MetadataUtils::ItemDataToBuffer(item_, &buffer);
351        (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count);
352        FreeMetadataBuffer(item_);
353    }
354}
355
356bool MetadataUtils::WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data)
357{
358    bool bRet = false;
359    size_t i;
360    if (item.data_type == META_TYPE_BYTE) {
361        std::vector<uint8_t> byteBuffers;
362        for (i = 0; i < item.count; i++) {
363            byteBuffers.push_back(*(item.data.u8 + i));
364        }
365        bRet = data.WriteUInt8Vector(byteBuffers);
366    } else if (item.data_type == META_TYPE_INT32) {
367        std::vector<int32_t> int32Buffers;
368        for (i = 0; i < item.count; i++) {
369            int32Buffers.push_back(*(item.data.i32 + i));
370        }
371        bRet = data.WriteInt32Vector(int32Buffers);
372    } else if (item.data_type == META_TYPE_FLOAT) {
373        std::vector<float> floatBuffers;
374        for (i = 0; i < item.count; i++) {
375            floatBuffers.push_back(*(item.data.f + i));
376        }
377        bRet = data.WriteFloatVector(floatBuffers);
378    } else if (item.data_type == META_TYPE_UINT32) {
379        std::vector<uint32_t> uInt32Buffers;
380        for (i = 0; i < item.count; i++) {
381            uInt32Buffers.push_back(*(item.data.ui32 + i));
382        }
383        bRet = data.WriteUInt32Vector(uInt32Buffers);
384    } else if (item.data_type == META_TYPE_INT64) {
385        std::vector<int64_t> int64Buffers;
386        for (i = 0; i < item.count; i++) {
387            int64Buffers.push_back(*(item.data.i64 + i));
388        }
389        bRet = data.WriteInt64Vector(int64Buffers);
390    } else if (item.data_type == META_TYPE_DOUBLE) {
391        std::vector<double> doubleBuffers;
392        for (i = 0; i < item.count; i++) {
393            doubleBuffers.push_back(*(item.data.d + i));
394        }
395        bRet = data.WriteDoubleVector(doubleBuffers);
396    } else if (item.data_type == META_TYPE_RATIONAL) {
397        std::vector<int32_t> rationalBuffers;
398        for (i = 0; i < item.count; i++) {
399            rationalBuffers.push_back((*(item.data.r + i)).numerator);
400            rationalBuffers.push_back((*(item.data.r + i)).denominator);
401        }
402        bRet = data.WriteInt32Vector(rationalBuffers);
403    }
404
405    return bRet;
406}
407
408std::string MetadataUtils::EncodeToString(std::shared_ptr<CameraMetadata> metadata)
409{
410    int32_t ret;
411    const int32_t headerLength = sizeof(common_metadata_header_t);
412    const int32_t itemLen = sizeof(camera_metadata_item_entry_t);
413    const int32_t itemFixedLen = static_cast<int32_t>(offsetof(camera_metadata_item_entry_t, data));
414
415    if (metadata == nullptr || metadata->get() == nullptr) {
416        METADATA_ERR_LOG("MetadataUtils::EncodeToString Metadata is invalid");
417        return {};
418    }
419
420    common_metadata_header_t *meta = metadata->get();
421    int32_t encodeDataLen = headerLength + (itemLen * meta->item_count) + meta->data_count;
422    std::string s(encodeDataLen, '\0');
423    char *encodeData = &s[0];
424    ret = memcpy_s(encodeData, encodeDataLen, meta, headerLength);
425    if (ret != EOK) {
426        METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for metadata header");
427        return {};
428    }
429    encodeData += headerLength;
430    encodeDataLen -= headerLength;
431    camera_metadata_item_entry_t *item = GetMetadataItems(meta);
432    for (uint32_t index = 0; index < meta->item_count; index++, item++) {
433        ret = memcpy_s(encodeData, encodeDataLen, item, itemFixedLen);
434        if (ret != EOK) {
435            METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item fixed fields");
436            return {};
437        }
438        encodeData += itemFixedLen;
439        encodeDataLen -= itemFixedLen;
440        int32_t dataLen = itemLen - itemFixedLen;
441        ret = memcpy_s(encodeData, encodeDataLen,  &(item->data), dataLen);
442        if (ret != EOK) {
443            METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for item data field");
444            return {};
445        }
446        encodeData += dataLen;
447        encodeDataLen -= dataLen;
448    }
449
450    if (meta->data_count != 0) {
451        ret = copyEncodeToStringMem(meta, encodeData, encodeDataLen);
452        if (ret != CAM_META_SUCCESS) {
453            return {};
454        }
455        encodeData += meta->data_count;
456    }
457    METADATA_DEBUG_LOG("MetadataUtils::EncodeToString Calculated length: %{public}zu, encoded length: %{public}zu",
458                       s.capacity(), (encodeData - &s[0]));
459
460    return s;
461}
462
463int MetadataUtils::copyEncodeToStringMem(common_metadata_header_t *meta, char *encodeData, int32_t encodeDataLen)
464{
465    uint8_t *metaMetadataData = GetMetadataData(meta);
466    int32_t ret = CAM_META_SUCCESS;
467    if (metaMetadataData == nullptr) {
468        METADATA_ERR_LOG("MetadataUtils::EncodeToString GetMetadataData failed");
469        return CAM_META_FAILURE;
470    }
471    ret = memcpy_s(encodeData, encodeDataLen, metaMetadataData, meta->data_count);
472    if (ret != EOK) {
473        METADATA_ERR_LOG("MetadataUtils::EncodeToString Failed to copy memory for data");
474        return CAM_META_FAILURE;
475    }
476    return CAM_META_SUCCESS;
477}
478
479std::shared_ptr<CameraMetadata> MetadataUtils::DecodeFromString(std::string setting)
480{
481    int32_t ret;
482    uint32_t totalLen = setting.capacity();
483    const uint32_t headerLength = sizeof(common_metadata_header_t);
484    const uint32_t itemLen = sizeof(camera_metadata_item_entry_t);
485    const uint32_t itemFixedLen = offsetof(camera_metadata_item_entry_t, data);
486
487    IF_COND_PRINT_MSG_AND_RETURN(totalLen < headerLength,
488        "MetadataUtils::DecodeFromString Length is less than metadata header length")
489
490    char *decodeData = &setting[0];
491    common_metadata_header_t header;
492    ret = memcpy_s(&header, headerLength, decodeData, headerLength);
493
494    IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
495        "MetadataUtils::DecodeFromString Failed to copy memory for metadata header")
496    std::shared_ptr<CameraMetadata> metadata
497        = std::make_shared<CameraMetadata>(header.item_capacity, header.data_capacity);
498    common_metadata_header_t *meta = metadata->get();
499
500    IF_COND_PRINT_MSG_AND_RETURN(!meta,
501        "MetadataUtils::DecodeFromString Failed to get metadata header")
502    uint32_t actualMemSize = meta->size;
503    ret = memcpy_s(meta, headerLength, &header, headerLength);
504
505    IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
506        "MetadataUtils::DecodeFromString Failed to copy memory for metadata header")
507    bool isItemsStartInvalid = meta->items_start >= actualMemSize || meta->items_start < headerLength;
508    bool isDataStartInvalid = meta->data_start >= actualMemSize || meta->data_start < headerLength;
509    bool isMetadataCountInvaild = (actualMemSize - meta->items_start) < (uint64_t)meta->item_count * itemLen ||
510        (actualMemSize - meta->data_start) < meta->data_count;
511    IF_COND_PRINT_MSG_AND_RETURN(isItemsStartInvalid || isDataStartInvalid || isMetadataCountInvaild,
512        "MetadataUtils::DecodeFromString invalid item_start")
513    decodeData += headerLength;
514    camera_metadata_item_entry_t *item = GetMetadataItems(meta);
515    for (uint32_t index = 0; index < meta->item_count; index++, item++) {
516        if (totalLen < ((decodeData - &setting[0]) + itemLen)) {
517            METADATA_ERR_LOG("MetadataUtils::DecodeFromString Failed at item index: %{public}u", index);
518            return {};
519        }
520        ret = memcpy_s(item, itemFixedLen, decodeData, itemFixedLen);
521
522        IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
523            "MetadataUtils::DecodeFromString Failed to copy memory for item fixed fields")
524        decodeData += itemFixedLen;
525        uint32_t dataLen = itemLen - itemFixedLen;
526        ret = memcpy_s(&(item->data), dataLen,  decodeData, dataLen);
527
528        IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
529            "MetadataUtils::DecodeFromString Failed to copy memory for item data field")
530        decodeData += dataLen;
531    }
532
533    char *decodeMetadataData = &setting[0];
534    ret = copyDecodeFromStringMem(meta, decodeData, decodeMetadataData, totalLen);
535    if (ret != CAM_META_SUCCESS) {
536        return {};
537    }
538
539    METADATA_DEBUG_LOG("MetadataUtils::DecodeFromString String length: %{public}zu, Decoded length: %{public}zu",
540                       setting.capacity(), (decodeData - &setting[0]));
541    return metadata;
542}
543
544int MetadataUtils::copyDecodeFromStringMem(common_metadata_header_t *meta, char *decodeData,
545    char *decodeMetadataData, uint32_t totalLen)
546{
547    if (meta->data_count != 0) {
548        IF_COND_PRINT_MSG_AND_RETURN(
549            totalLen < static_cast<uint32_t>(((decodeData - decodeMetadataData) + meta->data_count)),
550            "MetadataUtils::DecodeFromString Failed at data copy")
551        uint8_t *metaMetadataData = GetMetadataData(meta);
552        int32_t ret;
553        if (metaMetadataData == nullptr) {
554            METADATA_ERR_LOG("MetadataUtils::DecodeFromString GetMetadataData failed");
555            return CAM_META_FAILURE;
556        }
557        ret = memcpy_s(metaMetadataData, meta->data_count, decodeData, meta->data_count);
558
559        IF_COND_PRINT_MSG_AND_RETURN(ret != EOK,
560            "MetadataUtils::DecodeFromString Failed to copy memory for item data field")
561        decodeData += meta->data_count;
562        return CAM_META_SUCCESS;
563    }
564    return CAM_META_SUCCESS;
565}
566
567static void ReadMetadataUInt8(camera_metadata_item_t &entry, MessageParcel &data)
568{
569    std::vector<uint8_t> buffers;
570    data.ReadUInt8Vector(&buffers);
571    entry.data.u8 = new(std::nothrow) uint8_t[entry.count];
572    if (entry.data.u8 != nullptr) {
573        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
574            entry.data.u8[i] = buffers.at(i);
575        }
576    }
577}
578
579static void ReadMetadataInt32(camera_metadata_item_t &entry, MessageParcel &data)
580{
581    std::vector<int32_t> buffers;
582    data.ReadInt32Vector(&buffers);
583    entry.data.i32 = new(std::nothrow) int32_t[entry.count];
584    if (entry.data.i32 != nullptr) {
585        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
586            entry.data.i32[i] = buffers.at(i);
587        }
588    }
589}
590
591static void ReadMetadataUInt32(camera_metadata_item_t &entry, MessageParcel &data)
592{
593    std::vector<uint32_t> buffers;
594    data.ReadUInt32Vector(&buffers);
595    entry.data.ui32 = new(std::nothrow) uint32_t[entry.count];
596    if (entry.data.ui32 != nullptr) {
597        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
598            entry.data.ui32[i] = buffers.at(i);
599        }
600    }
601}
602
603static void ReadMetadataFloat(camera_metadata_item_t &entry, MessageParcel &data)
604{
605    std::vector<float> buffers;
606    data.ReadFloatVector(&buffers);
607    entry.data.f = new(std::nothrow) float[entry.count];
608    if (entry.data.f != nullptr) {
609        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
610            entry.data.f[i] = buffers.at(i);
611        }
612    }
613}
614
615static void ReadMetadataInt64(camera_metadata_item_t &entry, MessageParcel &data)
616{
617    std::vector<int64_t> buffers;
618    data.ReadInt64Vector(&buffers);
619    entry.data.i64 = new(std::nothrow) int64_t[entry.count];
620    if (entry.data.i64 != nullptr) {
621        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
622            entry.data.i64[i] = buffers.at(i);
623        }
624    }
625}
626
627static void ReadMetadataDouble(camera_metadata_item_t &entry, MessageParcel &data)
628{
629    std::vector<double> buffers;
630    data.ReadDoubleVector(&buffers);
631    entry.data.d = new(std::nothrow) double[entry.count];
632    if (entry.data.d != nullptr) {
633        for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
634            entry.data.d[i] = buffers.at(i);
635        }
636    }
637}
638
639static void ReadMetadataRational(camera_metadata_item_t &entry, MessageParcel &data)
640{
641    std::vector<int32_t> buffers;
642    data.ReadInt32Vector(&buffers);
643    if (buffers.size() < 1) {
644        METADATA_ERR_LOG("MetadataUtils::ReadMetadataRational the buffers size < 1");
645        entry.data.r = nullptr;
646        return;
647    }
648    entry.data.r = new(std::nothrow) camera_rational_t[entry.count];
649    if (entry.data.r != nullptr) {
650        for (size_t i = 0, j = 0;
651            i < entry.count && j < static_cast<size_t>(buffers.size() - 1);
652            i++, j += 2) { // 2:Take two elements from the buffer vector container
653            entry.data.r[i].numerator = buffers.at(j);
654            entry.data.r[i].denominator = buffers.at(j + 1);
655        }
656    }
657}
658bool MetadataUtils::ReadMetadata(camera_metadata_item_t &entry, MessageParcel &data)
659{
660    if (entry.count > MAX_SUPPORTED_ITEMS) {
661        entry.count = MAX_SUPPORTED_ITEMS;
662        METADATA_ERR_LOG("MetadataUtils::ReadMetadata item.count is more than supported value");
663    }
664    switch (entry.data_type) {
665        case META_TYPE_BYTE:
666            ReadMetadataUInt8(entry, data);
667            break;
668        case META_TYPE_INT32:
669            ReadMetadataInt32(entry, data);
670            break;
671        case META_TYPE_UINT32:
672            ReadMetadataUInt32(entry, data);
673            break;
674        case META_TYPE_FLOAT:
675            ReadMetadataFloat(entry, data);
676            break;
677        case META_TYPE_INT64:
678            ReadMetadataInt64(entry, data);
679            break;
680        case META_TYPE_DOUBLE:
681            ReadMetadataDouble(entry, data);
682            break;
683        case META_TYPE_RATIONAL:
684            ReadMetadataRational(entry, data);
685            break;
686    }
687    return true;
688}
689
690void MetadataUtils::ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer)
691{
692    if (buffer == nullptr) {
693        METADATA_ERR_LOG("MetadataUtils::ItemDataToBuffer buffer is null");
694        return;
695    }
696    if (item.data_type == META_TYPE_BYTE) {
697        *buffer = reinterpret_cast<void *>(item.data.u8);
698    } else if (item.data_type == META_TYPE_INT32) {
699        *buffer = reinterpret_cast<void *>(item.data.i32);
700    } else if (item.data_type == META_TYPE_FLOAT) {
701        *buffer = reinterpret_cast<void *>(item.data.f);
702    } else if (item.data_type == META_TYPE_UINT32) {
703        *buffer = reinterpret_cast<void *>(item.data.ui32);
704    } else if (item.data_type == META_TYPE_INT64) {
705        *buffer = reinterpret_cast<void *>(item.data.i64);
706    } else if (item.data_type == META_TYPE_DOUBLE) {
707        *buffer = reinterpret_cast<void *>(item.data.d);
708    } else if (item.data_type == META_TYPE_RATIONAL) {
709        *buffer = reinterpret_cast<void *>(item.data.r);
710    }
711}
712
713void MetadataUtils::FreeMetadataBuffer(camera_metadata_item_t &entry)
714{
715    if (entry.data_type == META_TYPE_BYTE) {
716        if (entry.data.u8 != nullptr) {
717            delete[] entry.data.u8;
718        }
719    } else if (entry.data_type == META_TYPE_INT32) {
720        if (entry.data.i32 != nullptr) {
721            delete[] entry.data.i32;
722        }
723    } else if (entry.data_type == META_TYPE_FLOAT) {
724        if (entry.data.f != nullptr) {
725            delete[] entry.data.f;
726        }
727    } else if (entry.data_type == META_TYPE_INT64) {
728        if (entry.data.i64 != nullptr) {
729            delete[] entry.data.i64;
730        }
731    } else if (entry.data_type == META_TYPE_UINT32) {
732        if (entry.data.ui32 != nullptr) {
733            delete[] entry.data.ui32;
734        }
735    } else if (entry.data_type == META_TYPE_DOUBLE) {
736        if (entry.data.d != nullptr) {
737            delete[] entry.data.d;
738        }
739    } else if (entry.data_type == META_TYPE_RATIONAL) {
740        if (entry.data.r != nullptr) {
741            delete[] entry.data.r;
742        }
743    }
744}
745} // Camera
746