summaryrefslogtreecommitdiff
path: root/src/ipa
diff options
context:
space:
mode:
authorJacopo Mondi <jacopo@jmondi.org>2019-09-15 17:30:26 +0300
committerLaurent Pinchart <laurent.pinchart@ideasonboard.com>2019-11-20 21:48:00 +0200
commit132d99bc8fac63d7473de6f62f7860b149f8e1c2 (patch)
treef6fbcb6ff234eaf3c44b71eed1c8215b736fc3c5 /src/ipa
parentbc9527de454670445a8d69b039e65c0e5c7a699e (diff)
ipa: Switch to the plain C API
Switch IPA communication to the plain C API. As the IPAInterface class is easier to use for pipeline handlers than a plain C API, retain it and add an IPAContextWrapper that translate between the C++ and the C APIs. On the IPA module side usage of IPAInterface may be desired for IPAs implemented in C++ that want to link to libcamera. For those IPAs, a new IPAInterfaceWrapper helper class is introduced to wrap the IPAInterface implemented internally by the IPA module into an ipa_context, ipa_context_ops and ipa_callback_ops. Signed-off-by: Jacopo Mondi <jacopo@jmondi.org> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Diffstat (limited to 'src/ipa')
-rw-r--r--src/ipa/ipa_vimc.cpp7
-rw-r--r--src/ipa/libipa/ipa_interface_wrapper.cpp240
-rw-r--r--src/ipa/libipa/ipa_interface_wrapper.h56
-rw-r--r--src/ipa/libipa/meson.build13
-rw-r--r--src/ipa/meson.build3
-rw-r--r--src/ipa/rkisp1/meson.build3
-rw-r--r--src/ipa/rkisp1/rkisp1.cpp5
7 files changed, 322 insertions, 5 deletions
diff --git a/src/ipa/ipa_vimc.cpp b/src/ipa/ipa_vimc.cpp
index 50ca8dd8..8f03e811 100644
--- a/src/ipa/ipa_vimc.cpp
+++ b/src/ipa/ipa_vimc.cpp
@@ -17,7 +17,10 @@
#include <ipa/ipa_interface.h>
#include <ipa/ipa_module_info.h>
+#include "libipa/ipa_interface_wrapper.h"
+
#include "log.h"
+#include "utils.h"
namespace libcamera {
@@ -108,9 +111,9 @@ const struct IPAModuleInfo ipaModuleInfo = {
LICENSE,
};
-IPAInterface *ipaCreate()
+struct ipa_context *ipaCreate()
{
- return new IPAVimc();
+ return new IPAInterfaceWrapper(utils::make_unique<IPAVimc>());
}
}
diff --git a/src/ipa/libipa/ipa_interface_wrapper.cpp b/src/ipa/libipa/ipa_interface_wrapper.cpp
new file mode 100644
index 00000000..80c5648f
--- /dev/null
+++ b/src/ipa/libipa/ipa_interface_wrapper.cpp
@@ -0,0 +1,240 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * ipa_interface_wrapper.cpp - Image Processing Algorithm interface wrapper
+ */
+
+#include "ipa_interface_wrapper.h"
+
+#include <map>
+#include <string.h>
+#include <unistd.h>
+#include <vector>
+
+#include <ipa/ipa_interface.h>
+
+#include "byte_stream_buffer.h"
+
+/**
+ * \file ipa_interface_wrapper.h
+ * \brief Image Processing Algorithm interface wrapper
+ */
+
+namespace libcamera {
+
+/**
+ * \class IPAInterfaceWrapper
+ * \brief Wrap an IPAInterface and expose it as an ipa_context
+ *
+ * This class implements the ipa_context API based on a provided IPAInterface.
+ * It helps IPAs that implement the IPAInterface API to provide the external
+ * ipa_context API.
+ *
+ * To use the wrapper, an IPA module simple creates a new instance of its
+ * IPAInterface implementation, and passes it to the constructor of the
+ * IPAInterfaceWrapper. As IPAInterfaceWrapper inherits from ipa_context, the
+ * constructed wrapper can then be directly returned from the IPA module's
+ * ipaCreate() function.
+ *
+ * \code{.cpp}
+ * class MyIPA : public IPAInterface
+ * {
+ * ...
+ * };
+ *
+ * struct ipa_context *ipaCreate()
+ * {
+ * return new IPAInterfaceWrapper(utils::make_unique<MyIPA>());
+ * }
+ * \endcode
+ *
+ * The wrapper takes ownership of the IPAInterface and will automatically
+ * delete it when the wrapper is destroyed.
+ */
+
+/**
+ * \brief Construct an IPAInterfaceWrapper wrapping \a interface
+ * \param[in] interface The interface to wrap
+ */
+IPAInterfaceWrapper::IPAInterfaceWrapper(std::unique_ptr<IPAInterface> interface)
+ : ipa_(std::move(interface)), callbacks_(nullptr), cb_ctx_(nullptr)
+{
+ ops = &operations_;
+
+ ipa_->queueFrameAction.connect(this, &IPAInterfaceWrapper::queueFrameAction);
+}
+
+void IPAInterfaceWrapper::destroy(struct ipa_context *_ctx)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+
+ delete ctx;
+}
+
+void IPAInterfaceWrapper::init(struct ipa_context *_ctx)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+
+ ctx->ipa_->init();
+}
+
+void IPAInterfaceWrapper::register_callbacks(struct ipa_context *_ctx,
+ const struct ipa_callback_ops *callbacks,
+ void *cb_ctx)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+
+ ctx->callbacks_ = callbacks;
+ ctx->cb_ctx_ = cb_ctx;
+}
+
+void IPAInterfaceWrapper::configure(struct ipa_context *_ctx,
+ const struct ipa_stream *streams,
+ unsigned int num_streams,
+ const struct ipa_control_info_map *maps,
+ unsigned int num_maps)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+
+ ctx->serializer_.reset();
+
+ /* Translate the IPA stream configurations map. */
+ std::map<unsigned int, IPAStream> ipaStreams;
+
+ for (unsigned int i = 0; i < num_streams; ++i) {
+ const struct ipa_stream &stream = streams[i];
+
+ ipaStreams[stream.id] = {
+ stream.pixel_format,
+ Size(stream.width, stream.height),
+ };
+ }
+
+ /* Translate the IPA entity controls map. */
+ std::map<unsigned int, const ControlInfoMap &> entityControls;
+ std::map<unsigned int, ControlInfoMap> infoMaps;
+
+ for (unsigned int i = 0; i < num_maps; ++i) {
+ const struct ipa_control_info_map &ipa_map = maps[i];
+ ByteStreamBuffer byteStream(ipa_map.data, ipa_map.size);
+ unsigned int id = ipa_map.id;
+
+ infoMaps[id] = ctx->serializer_.deserialize<ControlInfoMap>(byteStream);
+ entityControls.emplace(id, infoMaps[id]);
+ }
+
+ ctx->ipa_->configure(ipaStreams, entityControls);
+}
+
+void IPAInterfaceWrapper::map_buffers(struct ipa_context *_ctx,
+ const struct ipa_buffer *_buffers,
+ size_t num_buffers)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+ std::vector<IPABuffer> buffers(num_buffers);
+
+ for (unsigned int i = 0; i < num_buffers; ++i) {
+ const struct ipa_buffer &_buffer = _buffers[i];
+ IPABuffer &buffer = buffers[i];
+ std::vector<Plane> &planes = buffer.memory.planes();
+
+ buffer.id = _buffer.id;
+
+ planes.resize(_buffer.num_planes);
+ for (unsigned int j = 0; j < _buffer.num_planes; ++j) {
+ if (_buffer.planes[j].dmabuf != -1)
+ planes[j].setDmabuf(_buffer.planes[j].dmabuf,
+ _buffer.planes[j].length);
+ /** \todo Create a Dmabuf class to implement RAII. */
+ ::close(_buffer.planes[j].dmabuf);
+ }
+ }
+
+ ctx->ipa_->mapBuffers(buffers);
+}
+
+void IPAInterfaceWrapper::unmap_buffers(struct ipa_context *_ctx,
+ const unsigned int *_ids,
+ size_t num_buffers)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+ std::vector<unsigned int> ids(_ids, _ids + num_buffers);
+ ctx->ipa_->unmapBuffers(ids);
+}
+
+void IPAInterfaceWrapper::process_event(struct ipa_context *_ctx,
+ const struct ipa_operation_data *data)
+{
+ IPAInterfaceWrapper *ctx = static_cast<IPAInterfaceWrapper *>(_ctx);
+ IPAOperationData opData;
+
+ opData.operation = data->operation;
+
+ opData.data.resize(data->num_data);
+ memcpy(opData.data.data(), data->data,
+ data->num_data * sizeof(*data->data));
+
+ opData.controls.resize(data->num_lists);
+ for (unsigned int i = 0; i < data->num_lists; ++i) {
+ const struct ipa_control_list *c_list = &data->lists[i];
+ ByteStreamBuffer byteStream(c_list->data, c_list->size);
+ opData.controls[i] = ctx->serializer_.deserialize<ControlList>(byteStream);
+ }
+
+ ctx->ipa_->processEvent(opData);
+}
+
+void IPAInterfaceWrapper::queueFrameAction(unsigned int frame,
+ const IPAOperationData &data)
+{
+ if (!callbacks_)
+ return;
+
+ struct ipa_operation_data c_data;
+ c_data.operation = data.operation;
+ c_data.data = data.data.data();
+ c_data.num_data = data.data.size();
+
+ struct ipa_control_list control_lists[data.controls.size()];
+ c_data.lists = control_lists;
+ c_data.num_lists = data.controls.size();
+
+ std::size_t listsSize = 0;
+ for (const auto &list : data.controls)
+ listsSize += serializer_.binarySize(list);
+
+ std::vector<uint8_t> binaryData(listsSize);
+ ByteStreamBuffer byteStreamBuffer(binaryData.data(), listsSize);
+
+ unsigned int i = 0;
+ for (const auto &list : data.controls) {
+ struct ipa_control_list &c_list = control_lists[i];
+ c_list.size = serializer_.binarySize(list);
+
+ ByteStreamBuffer b = byteStreamBuffer.carveOut(c_list.size);
+ serializer_.serialize(list, b);
+
+ c_list.data = b.base();
+ }
+
+ callbacks_->queue_frame_action(cb_ctx_, frame, c_data);
+}
+
+#ifndef __DOXYGEN__
+/*
+ * This construct confuses Doygen and makes it believe that all members of the
+ * operations is a member of IPAInterfaceWrapper. It must thus be hidden.
+ */
+const struct ipa_context_ops IPAInterfaceWrapper::operations_ = {
+ .destroy = &IPAInterfaceWrapper::destroy,
+ .init = &IPAInterfaceWrapper::init,
+ .register_callbacks = &IPAInterfaceWrapper::register_callbacks,
+ .configure = &IPAInterfaceWrapper::configure,
+ .map_buffers = &IPAInterfaceWrapper::map_buffers,
+ .unmap_buffers = &IPAInterfaceWrapper::unmap_buffers,
+ .process_event = &IPAInterfaceWrapper::process_event,
+};
+#endif
+
+} /* namespace libcamera */
diff --git a/src/ipa/libipa/ipa_interface_wrapper.h b/src/ipa/libipa/ipa_interface_wrapper.h
new file mode 100644
index 00000000..17be2062
--- /dev/null
+++ b/src/ipa/libipa/ipa_interface_wrapper.h
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * ipa_interface_wrapper.h - Image Processing Algorithm interface wrapper
+ */
+#ifndef __LIBCAMERA_IPA_INTERFACE_WRAPPER_H__
+#define __LIBCAMERA_IPA_INTERFACE_WRAPPER_H__
+
+#include <memory>
+
+#include <ipa/ipa_interface.h>
+
+#include "control_serializer.h"
+
+namespace libcamera {
+
+class IPAInterfaceWrapper : public ipa_context
+{
+public:
+ IPAInterfaceWrapper(std::unique_ptr<IPAInterface> interface);
+
+private:
+ static void destroy(struct ipa_context *ctx);
+ static void init(struct ipa_context *ctx);
+ static void register_callbacks(struct ipa_context *ctx,
+ const struct ipa_callback_ops *callbacks,
+ void *cb_ctx);
+ static void configure(struct ipa_context *ctx,
+ const struct ipa_stream *streams,
+ unsigned int num_streams,
+ const struct ipa_control_info_map *maps,
+ unsigned int num_maps);
+ static void map_buffers(struct ipa_context *ctx,
+ const struct ipa_buffer *c_buffers,
+ size_t num_buffers);
+ static void unmap_buffers(struct ipa_context *ctx,
+ const unsigned int *ids,
+ size_t num_buffers);
+ static void process_event(struct ipa_context *ctx,
+ const struct ipa_operation_data *data);
+
+ static const struct ipa_context_ops operations_;
+
+ void queueFrameAction(unsigned int frame, const IPAOperationData &data);
+
+ std::unique_ptr<IPAInterface> ipa_;
+ const struct ipa_callback_ops *callbacks_;
+ void *cb_ctx_;
+
+ ControlSerializer serializer_;
+};
+
+} /* namespace libcamera */
+
+#endif /* __LIBCAMERA_IPA_INTERFACE_WRAPPER_H__ */
diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
new file mode 100644
index 00000000..6f3cd486
--- /dev/null
+++ b/src/ipa/libipa/meson.build
@@ -0,0 +1,13 @@
+libipa_headers = files([
+ 'ipa_interface_wrapper.h',
+])
+
+libipa_sources = files([
+ 'ipa_interface_wrapper.cpp',
+])
+
+libipa_includes = include_directories('..')
+
+libipa = static_library('ipa', libipa_sources,
+ include_directories : ipa_includes,
+ dependencies : libcamera_dep)
diff --git a/src/ipa/meson.build b/src/ipa/meson.build
index 4f2a4577..42180324 100644
--- a/src/ipa/meson.build
+++ b/src/ipa/meson.build
@@ -10,11 +10,14 @@ ipa_includes = [
libcamera_internal_includes,
]
+subdir('libipa')
+
foreach t : ipa_vimc_sources
ipa = shared_module(t[0], 'ipa_vimc.cpp',
name_prefix : '',
include_directories : ipa_includes,
dependencies : libcamera_dep,
+ link_with : libipa,
install : true,
install_dir : ipa_install_dir,
cpp_args : '-DLICENSE="' + t[1] + '"')
diff --git a/src/ipa/rkisp1/meson.build b/src/ipa/rkisp1/meson.build
index 1cab319c..521518bd 100644
--- a/src/ipa/rkisp1/meson.build
+++ b/src/ipa/rkisp1/meson.build
@@ -1,7 +1,8 @@
rkisp1_ipa = shared_module('ipa_rkisp1',
'rkisp1.cpp',
name_prefix : '',
- include_directories : ipa_includes,
+ include_directories : [ipa_includes, libipa_includes],
dependencies : libcamera_dep,
+ link_with : libipa,
install : true,
install_dir : ipa_install_dir)
diff --git a/src/ipa/rkisp1/rkisp1.cpp b/src/ipa/rkisp1/rkisp1.cpp
index 41babf0c..744a16ae 100644
--- a/src/ipa/rkisp1/rkisp1.cpp
+++ b/src/ipa/rkisp1/rkisp1.cpp
@@ -19,6 +19,7 @@
#include <libcamera/buffer.h>
#include <libcamera/control_ids.h>
#include <libcamera/request.h>
+#include <libipa/ipa_interface_wrapper.h>
#include "log.h"
#include "utils.h"
@@ -247,9 +248,9 @@ const struct IPAModuleInfo ipaModuleInfo = {
"LGPL-2.1-or-later",
};
-IPAInterface *ipaCreate()
+struct ipa_context *ipaCreate()
{
- return new IPARkISP1();
+ return new IPAInterfaceWrapper(utils::make_unique<IPARkISP1>());
}
}