[libcamera-devel,RFC,4/7] libcamera: ipa: add Soft IPA

19266 diff mbox series

diff --git a/include/libcamera/ipa/meson.build b/include/libcamera/ipa/meson.build
index f3b4881c..aaee5cbf 100644
--- a/include/libcamera/ipa/meson.build
+++ b/include/libcamera/ipa/meson.build
@@ -65,6 +65,7 @@  pipeline_ipa_mojom_mapping = {
     'ipu3': 'ipu3.mojom',
     'rkisp1': 'rkisp1.mojom',
     'rpi/vc4': 'raspberrypi.mojom',
+    'simple/linaro': 'soft.mojom',
     'vimc': 'vimc.mojom',
 }
 
diff --git a/include/libcamera/ipa/soft.mojom b/include/libcamera/ipa/soft.mojom
new file mode 100644
index 00000000..c3449188
--- /dev/null
+++ b/include/libcamera/ipa/soft.mojom
@@ -0,0 +1,27 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+/*
+ * \todo Document the interface and remove the related EXCLUDE_PATTERNS entry.
+ * \todo Add a way to tell SoftIPA the list of params SoftISP accepts?
+ */
+
+module ipa.soft;
+
+import "include/libcamera/ipa/core.mojom";
+
+interface IPASoftInterface {
+	init(libcamera.IPASettings settings,
+	     libcamera.SharedFD fdStats,
+	     libcamera.ControlInfoMap sensorCtrlInfoMap)
+		=> (int32 ret);
+	start() => (int32 ret);
+	stop();
+	configure(libcamera.ControlInfoMap sensorCtrlInfoMap)
+		=> (int32 ret);
+
+	[async] processStats(libcamera.ControlList sensorControls);
+};
+
+interface IPASoftEventInterface {
+	setSensorControls(libcamera.ControlList sensorControls);
+};
diff --git a/meson_options.txt b/meson_options.txt
index fad928af..2fb51ff4 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -27,7 +27,7 @@  option('gstreamer',
 
 option('ipas',
         type : 'array',
-        choices : ['ipu3', 'rkisp1', 'rpi/vc4', 'vimc'],
+        choices : ['ipu3', 'rkisp1', 'rpi/vc4', 'simple/linaro', 'vimc'],
         description : 'Select which IPA modules to build')
 
 option('lc-compliance',
@@ -46,6 +46,7 @@  option('pipelines',
             'rkisp1',
             'rpi/vc4',
             'simple',
+            'simple/linaro',
             'uvcvideo',
             'vimc'
         ],
diff --git a/src/ipa/simple/common/meson.build b/src/ipa/simple/common/meson.build
new file mode 100644
index 00000000..023e617b
--- /dev/null
+++ b/src/ipa/simple/common/meson.build
@@ -0,0 +1,17 @@ 
+# SPDX-License-Identifier: CC0-1.0
+
+soft_ipa_common_sources = files([
+    'soft_base.cpp',
+])
+
+soft_ipa_common_includes = [
+    include_directories('..'),
+]
+
+soft_ipa_common_deps = [
+    libcamera_private,
+]
+
+soft_ipa_common_lib = static_library('soft_ipa_common', soft_ipa_common_sources,
+                                     include_directories : soft_ipa_common_includes,
+                                     dependencies : soft_ipa_common_deps)
diff --git a/src/ipa/simple/common/soft_base.cpp b/src/ipa/simple/common/soft_base.cpp
new file mode 100644
index 00000000..7bd9b8de
--- /dev/null
+++ b/src/ipa/simple/common/soft_base.cpp
@@ -0,0 +1,66 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2023, Linaro Ltd
+ *
+ * soft-base.cpp - Software IPA base class
+ */
+
+#include "soft_base.h"
+
+#include <sys/mman.h>
+
+#include <libcamera/base/file.h>
+#include <libcamera/base/log.h>
+
+#include <libcamera/control_ids.h>
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(IPASoft)
+
+namespace ipa::soft {
+
+IPASoftBase::IPASoftBase()
+{
+}
+
+IPASoftBase::~IPASoftBase()
+{
+}
+
+int IPASoftBase::init([[maybe_unused]] const IPASettings &settings,
+		      const SharedFD &fdStats,
+		      const ControlInfoMap &sensorInfoMap)
+{
+	fdStats_ = std::move(fdStats);
+	if (!fdStats_.isValid()) {
+		LOG(IPASoft, Error) << "Invalid Statistics handle";
+		return -ENODEV;
+	}
+
+	return platformInit(sensorInfoMap);
+}
+
+int IPASoftBase::configure(const ControlInfoMap &sensorInfoMap)
+{
+	return platformConfigure(sensorInfoMap);
+}
+
+int IPASoftBase::start()
+{
+	return platformStart();
+}
+
+void IPASoftBase::stop()
+{
+	return platformStop();
+}
+
+void IPASoftBase::processStats(const ControlList &sensorControls)
+{
+	return platformProcessStats(sensorControls);
+}
+
+} /* namespace ipa::soft */
+
+} /* namespace libcamera */
diff --git a/src/ipa/simple/common/soft_base.h b/src/ipa/simple/common/soft_base.h
new file mode 100644
index 00000000..bff53713
--- /dev/null
+++ b/src/ipa/simple/common/soft_base.h
@@ -0,0 +1,47 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2023, Linaro Ltd
+ *
+ * soft-base.h - Software IPA base class
+ */
+#pragma once
+
+#include <libcamera/base/shared_fd.h>
+#include <libcamera/controls.h>
+
+#include <libcamera/ipa/soft_ipa_interface.h>
+
+namespace libcamera {
+
+namespace ipa::soft {
+
+class IPASoftBase : public ipa::soft::IPASoftInterface
+{
+public:
+	IPASoftBase();
+	~IPASoftBase();
+
+	int init(const IPASettings &settings,
+		 const SharedFD &fdStats,
+		 const ControlInfoMap &sensorInfoMap) override;
+	int configure(const ControlInfoMap &sensorInfoMap) override;
+
+	int start() override;
+	void stop() override;
+
+	void processStats(const ControlList &sensorControls) override;
+
+protected:
+	SharedFD fdStats_;
+
+private:
+	virtual int platformInit(const ControlInfoMap &sensorInfoMap) = 0;
+	virtual int platformConfigure(const ControlInfoMap &sensorInfoMap) = 0;
+	virtual int platformStart() = 0;
+	virtual void platformStop() = 0;
+	virtual void platformProcessStats(const ControlList &sensorControls) = 0;
+};
+
+} /* namespace ipa::soft */
+
+} /* namespace libcamera */
diff --git a/src/ipa/simple/linaro/data/meson.build b/src/ipa/simple/linaro/data/meson.build
new file mode 100644
index 00000000..f3464375
--- /dev/null
+++ b/src/ipa/simple/linaro/data/meson.build
@@ -0,0 +1,8 @@ 
+# SPDX-License-Identifier: CC0-1.0
+
+conf_files = files([
+    'soft.conf',
+])
+
+install_data(conf_files,
+             install_dir : ipa_data_dir / 'soft')
diff --git a/src/ipa/simple/linaro/data/soft.conf b/src/ipa/simple/linaro/data/soft.conf
new file mode 100644
index 00000000..0c70e7c0
--- /dev/null
+++ b/src/ipa/simple/linaro/data/soft.conf
@@ -0,0 +1,3 @@ 
+# SPDX-License-Identifier: LGPL-2.1-or-later
+#
+# Dummy configuration file for the soft IPA.
diff --git a/src/ipa/simple/linaro/meson.build b/src/ipa/simple/linaro/meson.build
new file mode 100644
index 00000000..97bf5d6f
--- /dev/null
+++ b/src/ipa/simple/linaro/meson.build
@@ -0,0 +1,26 @@ 
+# SPDX-License-Identifier: CC0-1.0
+
+ipa_name = 'ipa_soft_linaro'
+
+mod = shared_module(ipa_name,
+                    ['soft_linaro.cpp', libcamera_generated_ipa_headers],
+                    name_prefix : '',
+                    include_directories : [ipa_includes, libipa_includes, '..'],
+                    dependencies : libcamera_private,
+                    link_with : libipa,
+                    link_whole : soft_ipa_common_lib,
+                    install : true,
+                    install_dir : ipa_install_dir)
+
+if ipa_sign_module
+    custom_target(ipa_name + '.so.sign',
+                  input : mod,
+                  output : ipa_name + '.so.sign',
+                  command : [ipa_sign, ipa_priv_key, '@INPUT@', '@OUTPUT@'],
+                  install : false,
+                  build_by_default : true)
+endif
+
+subdir('data')
+
+ipa_names += ipa_name
diff --git a/src/ipa/simple/linaro/soft_linaro.cpp b/src/ipa/simple/linaro/soft_linaro.cpp
new file mode 100644
index 00000000..0b2e83bf
--- /dev/null
+++ b/src/ipa/simple/linaro/soft_linaro.cpp
@@ -0,0 +1,210 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2023, Linaro Ltd
+ *
+ * soft.cpp - Software Image Processing Algorithm module
+ */
+
+#include <sys/mman.h>
+
+#include <libcamera/base/file.h>
+#include <libcamera/base/log.h>
+
+#include <libcamera/control_ids.h>
+
+#include <libcamera/ipa/ipa_interface.h>
+#include <libcamera/ipa/ipa_module_info.h>
+
+#include "libcamera/internal/camera_sensor.h"
+#include "libcamera/internal/software_isp/statistics-linaro.h"
+
+#include "common/soft_base.h"
+
+namespace libcamera {
+
+LOG_DECLARE_CATEGORY(IPASoft)
+
+namespace ipa::soft {
+
+class IPASoftLinaro final : public IPASoftBase
+{
+public:
+	IPASoftLinaro()
+		: IPASoftBase(), ignore_updates_(0)
+	{
+	}
+
+	~IPASoftLinaro()
+	{
+		if (stats_)
+			munmap(stats_, sizeof(SwIspStats));
+	}
+
+	int platformInit(const ControlInfoMap &sensorInfoMap) override;
+	int platformConfigure(const ControlInfoMap &sensorInfoMap) override;
+	int platformStart() override;
+	void platformStop() override;
+	void platformProcessStats(const ControlList &sensorControls) override;
+
+private:
+	void update_exposure(double ev_adjustment);
+
+	SwIspStats *stats_;
+	int exposure_min_, exposure_max_;
+	int again_min_, again_max_;
+	int again_, exposure_;
+	int ignore_updates_;
+};
+
+int IPASoftLinaro::platformInit(const ControlInfoMap &sensorInfoMap)
+{
+	stats_ = static_cast<SwIspStats *>(mmap(nullptr, sizeof(SwIspStats),
+						PROT_READ | PROT_WRITE, MAP_SHARED,
+						fdStats_.get(), 0));
+	if (!stats_) {
+		LOG(IPASoft, Error) << "Unable to map Statistics";
+		return -ENODEV;
+	}
+
+	if (sensorInfoMap.find(V4L2_CID_EXPOSURE) == sensorInfoMap.end()) {
+		LOG(IPASoft, Error) << "Don't have exposure control";
+		return -EINVAL;
+	}
+
+	if (sensorInfoMap.find(V4L2_CID_ANALOGUE_GAIN) == sensorInfoMap.end()) {
+		LOG(IPASoft, Error) << "Don't have gain control";
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+int IPASoftLinaro::platformConfigure(const ControlInfoMap &sensorInfoMap)
+{
+	const ControlInfo &exposure_info = sensorInfoMap.find(V4L2_CID_EXPOSURE)->second;
+	const ControlInfo &gain_info = sensorInfoMap.find(V4L2_CID_ANALOGUE_GAIN)->second;
+
+	exposure_min_ = exposure_info.min().get<int>();
+	if (!exposure_min_) {
+		LOG(IPASoft, Warning) << "Minimum exposure is zero, that can't be linear";
+		exposure_min_ = 1;
+	}
+	exposure_max_ = exposure_info.max().get<int>();
+	again_min_ = gain_info.min().get<int>();
+	if (!again_min_) {
+		LOG(IPASoft, Warning) << "Minimum gain is zero, that can't be linear";
+		again_min_ = 100;
+	}
+	again_max_ = gain_info.max().get<int>();
+
+	LOG(IPASoft, Info) << "Exposure " << exposure_min_ << "-" << exposure_max_
+			   << ", gain " << again_min_ << "-" << again_max_;
+
+	return 0;
+}
+
+int IPASoftLinaro::platformStart()
+{
+	return 0;
+}
+
+void IPASoftLinaro::platformStop()
+{
+}
+
+void IPASoftLinaro::platformProcessStats(const ControlList &sensorControls)
+{
+	double ev_adjustment = 0.0;
+	ControlList ctrls(sensorControls);
+
+	/*
+	 * Use 2 frames delay to make sure that the exposure and the gain set
+	 * have applied to the camera sensor
+	 */
+	if (ignore_updates_ > 0) {
+		LOG(IPASoft, Debug) << "Skipping exposure update: "
+				    << ignore_updates_;
+		--ignore_updates_;
+		return;
+	}
+
+	if (stats_->bright_ratio < 0.01)
+		ev_adjustment = 1.1;
+	if (stats_->too_bright_ratio > 0.04)
+		ev_adjustment = 0.9;
+
+	if (ev_adjustment != 0.0) {
+		/* sanity check */
+		if (!sensorControls.contains(V4L2_CID_EXPOSURE) ||
+		    !sensorControls.contains(V4L2_CID_ANALOGUE_GAIN)) {
+			LOG(IPASoft, Error) << "Control(s) missing";
+			return;
+		}
+
+		exposure_ = ctrls.get(V4L2_CID_EXPOSURE).get<int>();
+		again_ = ctrls.get(V4L2_CID_ANALOGUE_GAIN).get<int>();
+
+		update_exposure(ev_adjustment);
+
+		ctrls.set(V4L2_CID_EXPOSURE, exposure_);
+		ctrls.set(V4L2_CID_ANALOGUE_GAIN, again_);
+
+		ignore_updates_ = 2;
+
+		setSensorControls.emit(ctrls);
+	}
+}
+
+void IPASoftLinaro::update_exposure(double ev_adjustment)
+{
+	double exp = (double)exposure_;
+	double gain = (double)again_;
+	double ev = ev_adjustment * exp * gain;
+
+	/*
+	 * Try to use the minimal possible analogue gain.
+	 * The exposure can be any value from exposure_min_ to exposure_max_,
+	 * and normally this should keep the frame rate intact.
+	 */
+
+	exp = ev / again_min_;
+	if (exp > exposure_max_)
+		exposure_ = exposure_max_;
+	else if (exp < exposure_min_)
+		exposure_ = exposure_min_;
+	else
+		exposure_ = (int)exp;
+
+	gain = ev / exposure_;
+	if (gain > again_max_)
+		again_ = again_max_;
+	else if (gain < again_min_)
+		again_ = again_min_;
+	else
+		again_ = (int)gain;
+
+	LOG(IPASoft, Debug) << "Desired EV = " << ev
+			    << ", real EV = " << (double)again_ * exposure_;
+}
+
+} /* namespace ipa::soft */
+
+/*
+ * External IPA module interface
+ */
+extern "C" {
+const struct IPAModuleInfo ipaModuleInfo = {
+	IPA_MODULE_API_VERSION,
+	0,
+	"SimplePipelineHandler",
+	"soft/linaro",
+};
+
+IPAInterface *ipaCreate()
+{
+	return new ipa::soft::IPASoftLinaro();
+}
+
+} /* extern "C" */
+
+} /* namespace libcamera */
diff --git a/src/ipa/simple/meson.build b/src/ipa/simple/meson.build
new file mode 100644
index 00000000..14be5dc2
--- /dev/null
+++ b/src/ipa/simple/meson.build
@@ -0,0 +1,12 @@ 
+# SPDX-License-Identifier: CC0-1.0
+
+subdir('common')
+
+foreach pipeline : pipelines
+    pipeline = pipeline.split('/')
+    if pipeline.length() < 2 or pipeline[0] != 'simple'
+        continue
+    endif
+
+    subdir(pipeline[1])
+endforeach