new file mode 100644
@@ -0,0 +1,876 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Google Inc.
+ *
+ * ipa_data_serializer.h - Image Processing Algorithm data serializer
+ */
+#ifndef __LIBCAMERA_INTERNAL_IPA_DATA_SERIALIZER_H__
+#define __LIBCAMERA_INTERNAL_IPA_DATA_SERIALIZER_H__
+
+#include <deque>
+#include <iostream>
+#include <tuple>
+#include <vector>
+
+#include <libcamera/buffer.h>
+#include <libcamera/control_ids.h>
+#include <libcamera/geometry.h>
+#include <libcamera/ipa/ipa_interface.h>
+
+#include "libcamera/internal/byte_stream_buffer.h"
+#include "libcamera/internal/camera_sensor.h"
+#include "libcamera/internal/control_serializer.h"
+#include "libcamera/internal/log.h"
+
+namespace libcamera {
+
+LOG_DECLARE_CATEGORY(IPADataSerializer)
+
+template<typename T>
+void appendUInt(std::vector<uint8_t> &vec, T val)
+{
+ size_t byteWidth = sizeof(val);
+ for (size_t i = 0; i < byteWidth; i++)
+ vec.push_back(static_cast<uint8_t>((val >> 8*i) & 0xff));
+}
+
+template<typename T>
+T readUInt(std::vector<uint8_t> &vec, size_t pos)
+{
+ T ret = 0;
+ size_t byteWidth = sizeof(ret);
+ if (pos + byteWidth > vec.size())
+ return ret;
+
+ for (size_t i = 0; i < byteWidth; i++)
+ ret |= vec[pos + i] << 8*i;
+ return ret;
+}
+
+template<typename T>
+T readUInt(std::vector<uint8_t>::iterator it)
+{
+ T ret = 0;
+ size_t byteWidth = sizeof(ret);
+ for (size_t i = 0; i < byteWidth; i++)
+ ret |= *(it + i) << 8*i;
+ return ret;
+}
+
+template<typename T>
+class IPADataSerializer
+{
+};
+
+template<typename V>
+class IPADataSerializer<std::vector<V>>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const std::vector<V> &data, ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+ std::vector<int32_t> fds_vec;
+
+ // serialize the length
+ uint32_t vec_len = data.size();
+ appendUInt<uint32_t>(data_vec, vec_len);
+
+ // serialize the members
+ for (auto it = data.begin(); it != data.end(); ++it) {
+ std::vector<uint8_t> dvec;
+ std::vector<int32_t> fvec;
+
+ std::tie(dvec, fvec) =
+ IPADataSerializer<V>::serialize(*it, cs);
+
+ appendUInt<uint32_t>(data_vec, dvec.size());
+ appendUInt<uint32_t>(data_vec, fvec.size());
+
+ data_vec.insert(data_vec.end(), dvec.begin(), dvec.end());
+ fds_vec.insert(fds_vec.end(), fvec.begin(), fvec.end());
+ }
+
+ return {data_vec, fds_vec};
+ }
+
+ static std::vector<V> deserialize(std::vector<uint8_t> &data, ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<std::vector<V>>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static std::vector<V> deserialize(std::vector<uint8_t>::iterator it1,
+ std::vector<uint8_t>::iterator it2,
+ ControlSerializer *cs = nullptr)
+ {
+ std::vector<int32_t> fds;
+ return IPADataSerializer<std::vector<V>>::deserialize(it1, it2,
+ fds.begin(), fds.end(),
+ cs);
+ }
+
+ static std::vector<V> deserialize(std::vector<uint8_t> &data, std::vector<int32_t> &fds,
+ ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<std::vector<V>>::deserialize(data.begin(), data.end(),
+ fds.begin(), fds.end(),
+ cs);
+ }
+
+ static std::vector<V> deserialize(std::vector<uint8_t>::iterator data_it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator data_it2,
+ std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs = nullptr)
+ {
+ uint32_t vec_len = readUInt<uint32_t>(data_it1);
+ std::vector<V> ret(vec_len);
+
+ std::vector<uint8_t>::iterator data_it = data_it1 + 4;
+ std::vector<int32_t>::iterator fd_it = fds_it1;
+ for (uint32_t i = 0; i < vec_len; i++) {
+ uint32_t sizeof_data = readUInt<uint32_t>(data_it);
+ uint32_t sizeof_fds = readUInt<uint32_t>(data_it + 4);
+
+ ret[i] = IPADataSerializer<V>::deserialize(data_it + 8,
+ data_it + 8 + sizeof_data,
+ fd_it,
+ fd_it + sizeof_fds,
+ cs);
+
+ data_it += 8 + sizeof_data;
+ fd_it += sizeof_fds;
+ }
+
+ return ret;
+ }
+};
+
+template<typename K, typename V>
+class IPADataSerializer<std::map<K, V>>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const std::map<K, V> &data, ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+ std::vector<int32_t> fds_vec;
+
+ // serialize the length
+ uint32_t map_len = data.size();
+ appendUInt<uint32_t>(data_vec, map_len);
+
+ // serialize the members
+ for (auto it = data.begin(); it != data.end(); ++it) {
+ std::vector<uint8_t> dvec;
+ std::vector<int32_t> fvec;
+
+ std::tie(dvec, fvec) =
+ IPADataSerializer<K>::serialize(it->first, cs);
+
+ appendUInt<uint32_t>(data_vec, dvec.size());
+ appendUInt<uint32_t>(data_vec, fvec.size());
+
+ data_vec.insert(data_vec.end(), dvec.begin(), dvec.end());
+ fds_vec.insert(fds_vec.end(), fvec.begin(), fvec.end());
+
+ std::tie(dvec, fvec) =
+ IPADataSerializer<V>::serialize(it->second, cs);
+
+ appendUInt<uint32_t>(data_vec, dvec.size());
+ appendUInt<uint32_t>(data_vec, fvec.size());
+
+ data_vec.insert(data_vec.end(), dvec.begin(), dvec.end());
+ fds_vec.insert(fds_vec.end(), fvec.begin(), fvec.end());
+ }
+
+ return {data_vec, fds_vec};
+ }
+
+ static std::map<K, V> deserialize(std::vector<uint8_t> &data, ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<std::map<K, V>>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static std::map<K, V> deserialize(std::vector<uint8_t>::iterator it1,
+ std::vector<uint8_t>::iterator it2,
+ ControlSerializer *cs = nullptr)
+ {
+ std::vector<int32_t> fds;
+ return IPADataSerializer<std::map<K, V>>::deserialize(it1, it2,
+ fds.begin(), fds.end(),
+ cs);
+ }
+
+ static std::map<K, V> deserialize(std::vector<uint8_t> &data, std::vector<int32_t> &fds,
+ ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<std::map<K, V>>::deserialize(data.begin(), data.end(),
+ fds.begin(), fds.end(),
+ cs);
+ }
+
+ static std::map<K, V> deserialize(std::vector<uint8_t>::iterator data_it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator data_it2,
+ std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs = nullptr)
+ {
+ std::map<K, V> ret;
+
+ uint32_t map_len = readUInt<uint32_t>(data_it1);
+
+ std::vector<uint8_t>::iterator data_it = data_it1 + 4;
+ std::vector<int32_t>::iterator fd_it = fds_it1;
+ for (uint32_t i = 0; i < map_len; i++) {
+ uint32_t sizeof_data = readUInt<uint32_t>(data_it);
+ uint32_t sizeof_fds = readUInt<uint32_t>(data_it + 4);
+
+ K key = IPADataSerializer<K>::deserialize(data_it + 8,
+ data_it + 8 + sizeof_data,
+ fd_it,
+ fd_it + sizeof_fds,
+ cs);
+
+ data_it += 8 + sizeof_data;
+ fd_it += sizeof_fds;
+ sizeof_data = readUInt<uint32_t>(data_it);
+ sizeof_fds = readUInt<uint32_t>(data_it + 4);
+
+ const V value = IPADataSerializer<V>::deserialize(data_it + 8,
+ data_it + 8 + sizeof_data,
+ fd_it,
+ fd_it + sizeof_fds,
+ cs);
+ ret.insert({key, value});
+
+ data_it += 8 + sizeof_data;
+ fd_it += sizeof_fds;
+ }
+
+ return ret;
+ }
+};
+
+// TODO implement this for all primitives
+template<>
+class IPADataSerializer<uint32_t>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const uint32_t data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+ appendUInt<uint32_t>(data_vec, data);
+
+ return {data_vec, {}};
+ }
+
+ static uint32_t deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<uint32_t>::deserialize(data.begin(), data.end());
+ }
+
+ static uint32_t deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return readUInt<uint32_t>(it1);
+ }
+
+ static uint32_t deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<uint32_t>::deserialize(data.begin(), data.end());
+ }
+
+ static uint32_t deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<uint32_t>::deserialize(data_it1, data_it2);
+ }
+};
+
+template<>
+class IPADataSerializer<FileDescriptor>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const FileDescriptor &data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec = { data.isValid() };
+ std::vector<int32_t> fd_vec;
+ if (data.isValid())
+ fd_vec.push_back(data.fd());
+
+ return {data_vec, fd_vec};
+ }
+
+ static FileDescriptor deserialize(std::vector<uint8_t> &data, std::vector<int32_t> &fds,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<FileDescriptor>::deserialize(data.begin(), data.end(),
+ fds.begin(), fds.end());
+ }
+
+ static FileDescriptor deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ std::vector<int32_t>::iterator fds_it1,
+ std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ if (std::distance(data_it1, data_it2) < 1)
+ LOG(IPADataSerializer, Fatal)
+ << "Invalid data to deserialize FileDescriptor";
+
+ bool valid = *data_it1;
+
+ if (valid && std::distance(fds_it1, fds_it2) < 1)
+ LOG(IPADataSerializer, Fatal)
+ << "Invalid fds to deserialize FileDescriptor";
+
+ return valid ? FileDescriptor(*fds_it1) : FileDescriptor();
+ }
+};
+
+template<>
+class IPADataSerializer<IPASettings>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const IPASettings &data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec(data.configurationFile.begin(),
+ data.configurationFile.end());
+
+ return {data_vec, {}};
+ }
+
+ static IPASettings deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPASettings>::deserialize(data.begin(), data.end());
+ }
+
+ static IPASettings deserialize(std::vector<uint8_t>::iterator it1,
+ std::vector<uint8_t>::iterator it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::string str(it1, it2);
+
+ IPASettings ret;
+ ret.configurationFile = str;
+
+ return ret;
+ }
+
+ static IPASettings deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPASettings>::deserialize(data.begin(), data.end());
+ }
+
+ static IPASettings deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPASettings>::deserialize(data_it1, data_it2);
+ }
+};
+
+template<>
+class IPADataSerializer<CameraSensorInfo>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const CameraSensorInfo &data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+
+ uint32_t str_len = data.model.size();
+ appendUInt<uint32_t>(data_vec, str_len);
+
+ data_vec.insert(data_vec.end(), data.model.begin(), data.model.end());
+
+ appendUInt<uint32_t>(data_vec, data.bitsPerPixel);
+
+ appendUInt<uint32_t>(data_vec, data.activeAreaSize.width);
+ appendUInt<uint32_t>(data_vec, data.activeAreaSize.height);
+
+ appendUInt<uint32_t>(data_vec, static_cast<uint32_t>(data.analogCrop.x));
+ appendUInt<uint32_t>(data_vec, static_cast<uint32_t>(data.analogCrop.y));
+ appendUInt<uint32_t>(data_vec, data.analogCrop.width);
+ appendUInt<uint32_t>(data_vec, data.analogCrop.height);
+
+ appendUInt<uint32_t>(data_vec, data.outputSize.width);
+ appendUInt<uint32_t>(data_vec, data.outputSize.height);
+
+ appendUInt<uint64_t>(data_vec, data.pixelRate);
+
+ appendUInt<uint32_t>(data_vec, data.lineLength);
+
+ return {data_vec, {}};
+ }
+
+ static CameraSensorInfo deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<CameraSensorInfo>::deserialize(data.begin(), data.end());
+ }
+
+ static CameraSensorInfo deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ CameraSensorInfo ret;
+
+ uint32_t str_len = readUInt<uint32_t>(it1);
+ std::string str(it1 + 4, it1 + 4 + str_len);
+ ret.model = str;
+
+ std::vector<uint8_t>::iterator it = it1 + 4 + str_len;
+
+ ret.bitsPerPixel = readUInt<uint32_t>(it);
+
+ ret.activeAreaSize.width = readUInt<uint32_t>(it + 4);
+ ret.activeAreaSize.height = readUInt<uint32_t>(it + 8);
+
+ ret.analogCrop.x = static_cast<int32_t>(readUInt<uint32_t>(it + 12));
+ ret.analogCrop.y = static_cast<int32_t>(readUInt<uint32_t>(it + 16));
+ ret.analogCrop.width = readUInt<uint32_t>(it + 20);
+ ret.analogCrop.height = readUInt<uint32_t>(it + 24);
+
+ ret.outputSize.width = readUInt<uint32_t>(it + 28);
+ ret.outputSize.height = readUInt<uint32_t>(it + 32);
+
+ ret.pixelRate = readUInt<uint64_t>(it + 36);
+
+ ret.lineLength = readUInt<uint64_t>(it + 44);
+
+ return ret;
+ }
+
+ static CameraSensorInfo deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<CameraSensorInfo>::deserialize(data.begin(), data.end());
+ }
+
+ static CameraSensorInfo deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<CameraSensorInfo>::deserialize(data_it1, data_it2);
+ }
+};
+
+template<>
+class IPADataSerializer<IPAStream>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const IPAStream &data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+
+ appendUInt<uint32_t>(data_vec, data.pixelFormat);
+
+ appendUInt<uint32_t>(data_vec, data.size.width);
+ appendUInt<uint32_t>(data_vec, data.size.height);
+
+ return {data_vec, {}};
+ }
+
+ static IPAStream deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPAStream>::deserialize(data.begin(), data.end());
+ }
+
+ static IPAStream deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ IPAStream ret;
+
+ ret.pixelFormat = readUInt<uint32_t>(it1);
+
+ ret.size.width = readUInt<uint32_t>(it1 + 4);
+ ret.size.height = readUInt<uint32_t>(it1 + 8);
+
+ return ret;
+ }
+
+ static IPAStream deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPAStream>::deserialize(data.begin(), data.end());
+ }
+
+ static IPAStream deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPAStream>::deserialize(data_it1, data_it2);
+ }
+};
+
+template<>
+class IPADataSerializer<ControlList>
+{
+public:
+ // map arg will be generated, since it's per-pipeline anyway
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const ControlList &data, const ControlInfoMap &map,
+ ControlSerializer *cs)
+ {
+ if (!cs)
+ LOG(IPADataSerializer, Fatal)
+ << "ControlSerializer not provided for serialization of ControlList";
+
+ size_t size = cs->binarySize(map);
+ std::vector<uint8_t> infoData(size);
+ ByteStreamBuffer buffer(infoData.data(), infoData.size());
+ int ret = cs->serialize(map, buffer);
+
+ if (ret < 0 || buffer.overflow()) {
+ LOG(IPADataSerializer, Error) << "Failed to serialize ControlList's ControlInfoMap";
+ return {{}, {}};
+ }
+
+ size = cs->binarySize(data);
+ std::vector<uint8_t> listData(size);
+ buffer = ByteStreamBuffer(listData.data(), listData.size());
+ ret = cs->serialize(data, buffer);
+
+ if (ret < 0 || buffer.overflow()) {
+ LOG(IPADataSerializer, Error) << "Failed to serialize ControlList";
+ return {{}, {}};
+ }
+
+ std::vector<uint8_t> data_vec;
+ appendUInt<uint32_t>(data_vec, infoData.size());
+ appendUInt<uint32_t>(data_vec, listData.size());
+ data_vec.insert(data_vec.end(), infoData.begin(), infoData.end());
+ data_vec.insert(data_vec.end(), listData.begin(), listData.end());
+
+ return {data_vec, {}};
+ }
+
+ static ControlList deserialize(std::vector<uint8_t> &data, ControlSerializer *cs)
+ {
+ return IPADataSerializer<ControlList>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static ControlList deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ ControlSerializer *cs)
+ {
+ if (!cs)
+ LOG(IPADataSerializer, Fatal)
+ << "ControlSerializer not provided for deserialization of ControlList";
+
+ uint32_t infoDataSize = readUInt<uint32_t>(it1);
+ uint32_t listDataSize = readUInt<uint32_t>(it1 + 4);
+
+ std::vector<uint8_t>::iterator it = it1 + 8;
+
+ std::vector<uint8_t> infoData(it, it + infoDataSize);
+ std::vector<uint8_t> listData(it + infoDataSize, it + infoDataSize + listDataSize);
+
+ ByteStreamBuffer buffer(const_cast<const uint8_t *>(infoData.data()), infoData.size());
+ ControlInfoMap map = cs->deserialize<ControlInfoMap>(buffer);
+ /* It's fine if map is empty. */
+ if (buffer.overflow()) {
+ LOG(IPADataSerializer, Error)
+ << "Failed to deserialize ControlLists's ControlInfoMap: buffer overflow";
+ return ControlList();
+ }
+
+ buffer = ByteStreamBuffer(const_cast<const uint8_t *>(listData.data()), listData.size());
+ ControlList list = cs->deserialize<ControlList>(buffer);
+ if (buffer.overflow())
+ LOG(IPADataSerializer, Error) << "Failed to deserialize ControlList: buffer overflow";
+ if (list.empty())
+ LOG(IPADataSerializer, Error) << "Failed to deserialize ControlList: empty list";
+
+ return list;
+ }
+
+ static ControlList deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ ControlSerializer *cs)
+ {
+ return IPADataSerializer<ControlList>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static ControlList deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs)
+ {
+ return IPADataSerializer<ControlList>::deserialize(data_it1, data_it2, cs);
+ }
+};
+
+template<>
+class IPADataSerializer<const ControlInfoMap>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const ControlInfoMap &map, ControlSerializer *cs)
+ {
+ if (!cs)
+ LOG(IPADataSerializer, Fatal)
+ << "ControlSerializer not provided for serialization of ControlInfoMap";
+
+ size_t size = cs->binarySize(map);
+ std::vector<uint8_t> infoData(size);
+ ByteStreamBuffer buffer(infoData.data(), infoData.size());
+ int ret = cs->serialize(map, buffer);
+
+ if (ret < 0 || buffer.overflow())
+ return {{}, {}};
+
+ std::vector<uint8_t> data_vec;
+ appendUInt<uint32_t>(data_vec, infoData.size());
+ data_vec.insert(data_vec.end(), infoData.begin(), infoData.end());
+
+ return {data_vec, {}};
+ }
+
+ static const ControlInfoMap deserialize(std::vector<uint8_t> &data,
+ ControlSerializer *cs)
+ {
+ return IPADataSerializer<const ControlInfoMap>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static const ControlInfoMap deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ ControlSerializer *cs)
+ {
+ if (!cs)
+ LOG(IPADataSerializer, Fatal)
+ << "ControlSerializer not provided for deserialization of ControlInfoMap";
+
+ uint32_t infoDataSize = readUInt<uint32_t>(it1);
+
+ std::vector<uint8_t>::iterator it = it1 + 4;
+
+ std::vector<uint8_t> infoData(it, it + infoDataSize);
+
+ ByteStreamBuffer buffer(const_cast<const uint8_t *>(infoData.data()), infoData.size());
+ const ControlInfoMap map = cs->deserialize<ControlInfoMap>(buffer);
+
+ /*
+ ControlInfoMap::Map ctrls;
+ for (auto pair : map)
+ ctrls.emplace(controls::controls.at(pair.first->id()),
+ pair.second);
+
+ ControlInfoMap ret = std::move(ctrls);
+ return ret;
+ */
+
+ return map;
+ }
+
+ static const ControlInfoMap deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ ControlSerializer *cs)
+ {
+ return IPADataSerializer<const ControlInfoMap>::deserialize(data.begin(), data.end(), cs);
+ }
+
+ static const ControlInfoMap deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs)
+ {
+ return IPADataSerializer<const ControlInfoMap>::deserialize(data_it1, data_it2, cs);
+ }
+};
+
+template<>
+class IPADataSerializer<ControlInfoMap>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize([[maybe_unused]] const ControlInfoMap &map, [[maybe_unused]] ControlSerializer *cs)
+ {
+ const ControlInfoMap &map_const = const_cast<const ControlInfoMap &>(map);
+
+ std::vector<uint8_t> data_vec;
+ std::tie(data_vec, std::ignore) =
+ IPADataSerializer<const ControlInfoMap>::serialize(map_const, cs);
+
+ return {data_vec, {}};
+ }
+
+ static ControlInfoMap deserialize(std::vector<uint8_t> &data,
+ ControlSerializer *cs)
+ {
+ ControlInfoMap ret;
+ const ControlInfoMap &map = ret;
+ const_cast<ControlInfoMap &>(map) =
+ IPADataSerializer<const ControlInfoMap>::deserialize(data, cs);
+
+ return ret;
+ }
+
+ static ControlInfoMap deserialize(std::vector<uint8_t>::iterator it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator it2,
+ ControlSerializer *cs)
+ {
+ ControlInfoMap ret;
+ const ControlInfoMap &map = ret;
+ const_cast<ControlInfoMap &>(map) =
+ IPADataSerializer<const ControlInfoMap>::deserialize(it1, it2, cs);
+
+ return ret;
+ }
+
+ static ControlInfoMap deserialize(std::vector<uint8_t> &data,
+ [[maybe_unused]] std::vector<int32_t> &fds,
+ ControlSerializer *cs)
+ {
+ ControlInfoMap ret;
+ const ControlInfoMap &map = ret;
+ const_cast<ControlInfoMap &>(map) =
+ IPADataSerializer<const ControlInfoMap>::deserialize(data, fds, cs);
+
+ return ret;
+ }
+
+ static ControlInfoMap deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs)
+ {
+ ControlInfoMap ret;
+ const ControlInfoMap &map = ret;
+ const_cast<ControlInfoMap &>(map) =
+ IPADataSerializer<const ControlInfoMap>::deserialize(data_it1, data_it2,
+ fds_it1, fds_it2, cs);
+
+ return ret;
+ }
+};
+
+template<>
+class IPADataSerializer<FrameBuffer::Plane>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const FrameBuffer::Plane &data, [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+ std::vector<int32_t> fds_vec;
+
+ // fd
+ std::vector<uint8_t> fdBuf;
+ std::vector<int32_t> fdFds;
+ std::tie(fdBuf, fdFds) =
+ IPADataSerializer<FileDescriptor>::serialize(data.fd);
+ data_vec.insert(data_vec.end(), fdBuf.begin(), fdBuf.end());
+ fds_vec.insert(fds_vec.end(), fdFds.begin(), fdFds.end());
+
+ // length
+ appendUInt<uint32_t>(data_vec, data.length);
+
+ return {data_vec, fds_vec};
+ }
+
+ static FrameBuffer::Plane deserialize(std::vector<uint8_t> &data,
+ std::vector<int32_t> &fds,
+ ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<FrameBuffer::Plane>::deserialize(data.begin(), data.end(),
+ fds.begin(), fds.end(),
+ cs);
+ }
+
+ static FrameBuffer::Plane deserialize(std::vector<uint8_t>::iterator data_it1,
+ [[maybe_unused]] std::vector<uint8_t>::iterator data_it2,
+ std::vector<int32_t>::iterator fds_it1,
+ [[maybe_unused]] std::vector<int32_t>::iterator fds_it2,
+ [[maybe_unused]] ControlSerializer *cs = nullptr)
+ {
+ FrameBuffer::Plane ret;
+
+ ret.fd = IPADataSerializer<FileDescriptor>::deserialize(data_it1, data_it1 + 1,
+ fds_it1, fds_it1 + 1);
+ ret.length = readUInt<uint32_t>(data_it1 + 1);
+
+ return ret;
+ }
+};
+
+
+template<>
+class IPADataSerializer<IPABuffer>
+{
+public:
+ static std::tuple<std::vector<uint8_t>, std::vector<int32_t>>
+ serialize(const IPABuffer &data, ControlSerializer *cs = nullptr)
+ {
+ std::vector<uint8_t> data_vec;
+
+ appendUInt<uint32_t>(data_vec, data.id);
+
+ std::vector<uint8_t> planes_data_vec;
+ std::vector<int32_t> planes_fds_vec;
+ std::tie(planes_data_vec, planes_fds_vec) =
+ IPADataSerializer<std::vector<FrameBuffer::Plane>>::serialize(data.planes, cs);
+
+ data_vec.insert(data_vec.end(), planes_data_vec.begin(), planes_data_vec.end());
+
+ return {data_vec, planes_fds_vec};
+ }
+
+ static IPABuffer deserialize(std::vector<uint8_t> &data,
+ std::vector<int32_t> &fds,
+ ControlSerializer *cs = nullptr)
+ {
+ return IPADataSerializer<IPABuffer>::deserialize(data.begin(), data.end(),
+ fds.begin(), fds.end(), cs);
+ }
+
+ static IPABuffer deserialize(std::vector<uint8_t>::iterator data_it1,
+ std::vector<uint8_t>::iterator data_it2,
+ std::vector<int32_t>::iterator fds_it1,
+ std::vector<int32_t>::iterator fds_it2,
+ ControlSerializer *cs = nullptr)
+ {
+ IPABuffer ret;
+
+ ret.id = readUInt<uint32_t>(data_it1);
+
+ ret.planes =
+ IPADataSerializer<std::vector<FrameBuffer::Plane>>::deserialize(
+ data_it1 + 4, data_it2, fds_it1, fds_it2, cs);
+
+ return ret;
+ }
+};
+
+} /* namespace libcamera */
+
+#endif /* __LIBCAMERA_INTERNAL_IPA_DATA_SERIALIZER_H__ */
new file mode 100644
@@ -0,0 +1,29 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Google Inc.
+ *
+ * ipa_data_serializer.cpp - Image Processing Algorithm data serializer
+ */
+
+#include "libcamera/internal/ipa_data_serializer.h"
+
+#include "libcamera/internal/log.h"
+
+/**
+ * \file ipa_ipa_data_serializer.h
+ * \brief IPA Data Serializer
+ */
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(IPADataSerializer)
+
+/**
+ * \class IPADataSerializer
+ * \brief IPA Data Serializer
+ *
+ */
+
+// TODO the rest of the documentation
+
+} /* namespace libcamera */
@@ -23,6 +23,7 @@ libcamera_sources = files([
'geometry.cpp',
'ipa_context_wrapper.cpp',
'ipa_controls.cpp',
+ 'ipa_data_serializer.cpp',
'ipa_interface.cpp',
'ipa_manager.cpp',
'ipa_module.cpp',
Add an IPADataSerializer which implments de/serialization of built-in and libcamera data structures. This is intended to be used by the proxy and the proxy worker in the IPC layer. Signed-off-by: Paul Elder <paul.elder@ideasonboard.com> --- .../libcamera/internal/ipa_data_serializer.h | 876 ++++++++++++++++++ src/libcamera/ipa_data_serializer.cpp | 29 + src/libcamera/meson.build | 1 + 3 files changed, 906 insertions(+) create mode 100644 include/libcamera/internal/ipa_data_serializer.h create mode 100644 src/libcamera/ipa_data_serializer.cpp