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#ifndef OHOS_CAMERA_METADATA_UTILS_H
17#define OHOS_CAMERA_METADATA_UTILS_H
18
19#include <iostream>
20#include <list>
21#include <map>
22#include <vector>
23
24#include "camera_metadata_info.h"
25#include "message_parcel.h"
26
27namespace OHOS::Camera {
28class MetadataUtils {
29public:
30    static bool EncodeCameraMetadata(const std::shared_ptr<CameraMetadata> &metadata,
31                                     MessageParcel &data);
32    static void DecodeCameraMetadata(MessageParcel &data, std::shared_ptr<CameraMetadata> &metadata);
33
34    static std::string EncodeToString(std::shared_ptr<CameraMetadata> metadata);
35    static std::shared_ptr<CameraMetadata> DecodeFromString(std::string setting);
36    static bool ConvertMetadataToVec(const std::shared_ptr<CameraMetadata> &metadata,
37        std::vector<uint8_t>& cameraAbility);
38    static void ConvertVecToMetadata(const std::vector<uint8_t>& cameraAbility,
39        std::shared_ptr<CameraMetadata> &metadata);
40    static void FreeMetadataBuffer(camera_metadata_item_t &entry);
41
42    template <class T> static void WriteData(T data, std::vector<uint8_t>& cameraAbility);
43    template <class T> static void ReadData(T &data, int32_t &index, const std::vector<uint8_t>& cameraAbility);
44private:
45    static bool WriteMetadata(const camera_metadata_item_t &item, MessageParcel &data);
46    static bool ReadMetadata(camera_metadata_item_t &item, MessageParcel &data);
47    static void ItemDataToBuffer(const camera_metadata_item_t &item, void **buffer);
48    static void WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector<uint8_t>& cameraAbility);
49    static void ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry,
50        const std::vector<uint8_t>& cameraAbility);
51    static int copyEncodeToStringMem(common_metadata_header_t *meta, char *encodeData, int32_t encodeDataLen);
52    static int copyDecodeFromStringMem(common_metadata_header_t *meta, char *decodeData,
53        char *decodeMetadataData, uint32_t totalLen);
54};
55
56template <class T>
57void MetadataUtils::WriteData(T data, std::vector<uint8_t>& cameraAbility)
58{
59    T dataTemp = data;
60    uint8_t *dataPtr = reinterpret_cast<uint8_t *>(&dataTemp);
61    for (size_t j = 0; j < sizeof(T); j++) {
62        cameraAbility.push_back(*(dataPtr + j));
63    }
64}
65
66template <class T>
67void MetadataUtils::ReadData(T &data, int32_t &index, const std::vector<uint8_t>& cameraAbility)
68{
69    constexpr uint32_t typeLen = sizeof(T);
70    uint8_t array[typeLen] = {0};
71    T *ptr = nullptr;
72    for (size_t j = 0; j < sizeof(T); j++) {
73        array[j] = cameraAbility.at(index++);
74    }
75    ptr = reinterpret_cast<T *>(array);
76    data = *ptr;
77}
78} // namespace Camera
79#endif // OHOS_CAMERA_METADATA_UTILS_H
80