ipa: rkisp1: Take into account color temperature during LSC algorithm

Add coefficients sets in the YAML tuning file to allow using different set
depending of the image color temperature (provided by AWB algorithm).

During processing, LSC algorithm computes coefficients by doing a linear
interpolation between the two closer set.

Signed-off-by: Florian Sylvestre <fsylvestre@baylibre.com>
Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

2 files changed, 197 insertions, 29 deletions

diff --git a/src/ipa/rkisp1/algorithms/lsc.cpp b/src/ipa/rkisp1/algorithms/lsc.cpp
index e1c59033..3a443e77 100644
--- a/src/ipa/rkisp1/algorithms/lsc.cpp
+++ b/src/ipa/rkisp1/algorithms/lsc.cpp
@@ -7,6 +7,7 @@
 
 #include "lsc.h"
 
+#include <algorithm>
 #include <cmath>
 #include <numeric>
 
@@ -89,6 +90,7 @@ static std::vector<uint16_t> parseTable(const YamlObject &tuningData,
 }
 
 LensShadingCorrection::LensShadingCorrection()
+	: lastCt_({ 0, 0 })
 {
 }
 
@@ -104,14 +106,46 @@ int LensShadingCorrection::init([[maybe_unused]] IPAContext &context,
 	if (xSize_.empty() || ySize_.empty())
 		return -EINVAL;
 
-	rData_ = parseTable(tuningData, "r");
-	grData_ = parseTable(tuningData, "gr");
-	gbData_ = parseTable(tuningData, "gb");
-	bData_ = parseTable(tuningData, "b");
+	/* Get all defined sets to apply. */
+	const YamlObject &yamlSets = tuningData["sets"];
+	if (!yamlSets.isList()) {
+		LOG(RkISP1Lsc, Error)
+			<< "'sets' parameter not found in tuning file";
+		return -EINVAL;
+	}
+
+	const auto &sets = yamlSets.asList();
+	for (const auto &yamlSet : sets) {
+		uint32_t ct = yamlSet["ct"].get<uint32_t>(0);
+
+		if (sets_.count(ct)) {
+			LOG(RkISP1Lsc, Error)
+				<< "Multiple sets found for color temperature "
+				<< ct;
+			return -EINVAL;
+		}
+
+		Components &set = sets_[ct];
+
+		set.ct = ct;
+		set.r = parseTable(yamlSet, "r");
+		set.gr = parseTable(yamlSet, "gr");
+		set.gb = parseTable(yamlSet, "gb");
+		set.b = parseTable(yamlSet, "b");
+
+		if (set.r.empty() || set.gr.empty() ||
+		    set.gb.empty() || set.b.empty()) {
+			LOG(RkISP1Lsc, Error)
+				<< "Set for color temperature " << ct
+				<< " is missing tables";
+			return -EINVAL;
+		}
+	}
 
-	if (rData_.empty() || grData_.empty() ||
-	    gbData_.empty() || bData_.empty())
+	if (sets_.empty()) {
+		LOG(RkISP1Lsc, Error) << "Failed to load any sets";
 		return -EINVAL;
+	}
 
 	return 0;
 }
@@ -151,36 +185,154 @@ int LensShadingCorrection::configure(IPAContext &context,
 	return 0;
 }
 
+void LensShadingCorrection::setParameters(rkisp1_params_cfg *params)
+{
+	struct rkisp1_cif_isp_lsc_config &config = params->others.lsc_config;
+
+	memcpy(config.x_grad_tbl, xGrad_, sizeof(config.x_grad_tbl));
+	memcpy(config.y_grad_tbl, yGrad_, sizeof(config.y_grad_tbl));
+	memcpy(config.x_size_tbl, xSizes_, sizeof(config.x_size_tbl));
+	memcpy(config.y_size_tbl, ySizes_, sizeof(config.y_size_tbl));
+
+	params->module_en_update |= RKISP1_CIF_ISP_MODULE_LSC;
+	params->module_ens |= RKISP1_CIF_ISP_MODULE_LSC;
+	params->module_cfg_update |= RKISP1_CIF_ISP_MODULE_LSC;
+}
+
+void LensShadingCorrection::copyTable(rkisp1_cif_isp_lsc_config &config,
+				      const Components &set)
+{
+	std::copy(set.r.begin(), set.r.end(), &config.r_data_tbl[0][0]);
+	std::copy(set.gr.begin(), set.gr.end(), &config.gr_data_tbl[0][0]);
+	std::copy(set.gb.begin(), set.gb.end(), &config.gb_data_tbl[0][0]);
+	std::copy(set.b.begin(), set.b.end(), &config.b_data_tbl[0][0]);
+}
+
+/*
+ * Interpolate LSC parameters based on color temperature value.
+ */
+void LensShadingCorrection::interpolateTable(rkisp1_cif_isp_lsc_config &config,
+					     const Components &set0,
+					     const Components &set1,
+					     const uint32_t ct)
+{
+	double coeff0 = (set1.ct - ct) / (set1.ct - set0.ct);
+	double coeff1 = (ct - set0.ct) / (set1.ct - set0.ct);
+
+	for (unsigned int i = 0; i < RKISP1_CIF_ISP_LSC_SAMPLES_MAX; ++i) {
+		for (unsigned int j = 0; j < RKISP1_CIF_ISP_LSC_SAMPLES_MAX; ++j) {
+			unsigned int sample = i * RKISP1_CIF_ISP_LSC_SAMPLES_MAX + j;
+
+			config.r_data_tbl[i][j] =
+				set0.r[sample] * coeff0 +
+				set1.r[sample] * coeff1;
+
+			config.gr_data_tbl[i][j] =
+				set0.gr[sample] * coeff0 +
+				set1.gr[sample] * coeff1;
+
+			config.gb_data_tbl[i][j] =
+				set0.gb[sample] * coeff0 +
+				set1.gb[sample] * coeff1;
+
+			config.b_data_tbl[i][j] =
+				set0.b[sample] * coeff0 +
+				set1.b[sample] * coeff1;
+		}
+	}
+}
+
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void LensShadingCorrection::prepare([[maybe_unused]] IPAContext &context,
+void LensShadingCorrection::prepare(IPAContext &context,
 				    const uint32_t frame,
 				    [[maybe_unused]] IPAFrameContext &frameContext,
 				    rkisp1_params_cfg *params)
 {
-	if (frame > 0)
+	struct rkisp1_cif_isp_lsc_config &config = params->others.lsc_config;
+
+	/*
+	 * If there is only one set, the configuration has already been done
+	 * for first frame.
+	 */
+	if (sets_.size() == 1 && frame > 0)
 		return;
 
-	struct rkisp1_cif_isp_lsc_config &config = params->others.lsc_config;
+	/*
+	 * If there is only one set, pick it. We can ignore lastCt_, as it will
+	 * never be relevant.
+	 */
+	if (sets_.size() == 1) {
+		setParameters(params);
+		copyTable(config, sets_.cbegin()->second);
+		return;
+	}
 
-	memcpy(config.x_grad_tbl, xGrad_, sizeof(config.x_grad_tbl));
-	memcpy(config.y_grad_tbl, yGrad_, sizeof(config.y_grad_tbl));
-	memcpy(config.x_size_tbl, xSizes_, sizeof(config.x_size_tbl));
-	memcpy(config.y_size_tbl, ySizes_, sizeof(config.y_size_tbl));
+	uint32_t ct = context.activeState.awb.temperatureK;
+	ct = std::clamp(ct, sets_.cbegin()->first, sets_.crbegin()->first);
 
-	std::copy(rData_.begin(), rData_.end(),
-		  &config.r_data_tbl[0][0]);
-	std::copy(grData_.begin(), grData_.end(),
-		  &config.gr_data_tbl[0][0]);
-	std::copy(gbData_.begin(), gbData_.end(),
-		  &config.gb_data_tbl[0][0]);
-	std::copy(bData_.begin(), bData_.end(),
-		  &config.b_data_tbl[0][0]);
+	/*
+	 * If the original is the same, then it means the same adjustment would
+	 * be made. If the adjusted is the same, then it means that it's the
+	 * same as what was actually applied. Thus in these cases we can skip
+	 * reprogramming the LSC.
+	 *
+	 * original == adjusted can only happen if an interpolation
+	 * happened, or if original has an exact entry in sets_. This means
+	 * that if original != adjusted, then original was adjusted to
+	 * the nearest available entry in sets_, resulting in adjusted.
+	 * Clearly, any ct value that is in between original and adjusted
+	 * will be adjusted to the same adjusted value, so we can skip
+	 * reprogramming the LSC table.
+	 *
+	 * We also skip updating the original value, as the last one had a
+	 * larger bound and thus a larger range of ct values that will be
+	 * adjusted to the same adjusted.
+	 */
+	if ((lastCt_.original <= ct && ct <= lastCt_.adjusted) ||
+	    (lastCt_.adjusted <= ct && ct <= lastCt_.original))
+		return;
 
-	params->module_en_update |= RKISP1_CIF_ISP_MODULE_LSC;
-	params->module_ens |= RKISP1_CIF_ISP_MODULE_LSC;
-	params->module_cfg_update |= RKISP1_CIF_ISP_MODULE_LSC;
+	setParameters(params);
+
+	/*
+	 * The color temperature matches exactly one of the available LSC tables.
+	 */
+	if (sets_.count(ct)) {
+		copyTable(config, sets_[ct]);
+		lastCt_ = { ct, ct };
+		return;
+	}
+
+	/* No shortcuts left; we need to round or interpolate */
+	auto iter = sets_.upper_bound(ct);
+	const Components &set1 = iter->second;
+	const Components &set0 = (--iter)->second;
+	uint32_t ct0 = set0.ct;
+	uint32_t ct1 = set1.ct;
+	uint32_t diff0 = ct - ct0;
+	uint32_t diff1 = ct1 - ct;
+	static constexpr double kThreshold = 0.1;
+	float threshold = kThreshold * (ct1 - ct0);
+
+	if (diff0 < threshold || diff1 < threshold) {
+		const Components &set = diff0 < diff1 ? set0 : set1;
+		LOG(RkISP1Lsc, Debug) << "using LSC table for " << set.ct;
+		copyTable(config, set);
+		lastCt_ = { ct, set.ct };
+		return;
+	}
+
+	/*
+	 * ct is not within 10% of the difference between the neighbouring
+	 * color temperatures, so we need to interpolate.
+	 */
+	LOG(RkISP1Lsc, Debug)
+		<< "ct is " << ct << ", interpolating between "
+		<< ct0 << " and " << ct1;
+	interpolateTable(config, set0, set1, ct);
+	lastCt_ = { ct, ct };
 }
 
 REGISTER_IPA_ALGORITHM(LensShadingCorrection, "LensShadingCorrection")
diff --git a/src/ipa/rkisp1/algorithms/lsc.h b/src/ipa/rkisp1/algorithms/lsc.h
index da81ea53..e2a93a56 100644
--- a/src/ipa/rkisp1/algorithms/lsc.h
+++ b/src/ipa/rkisp1/algorithms/lsc.h
@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <map>
+
 #include "algorithm.h"
 
 namespace libcamera {
@@ -26,17 +28,31 @@ public:
 		     rkisp1_params_cfg *params) override;
 
 private:
-	std::vector<uint16_t> rData_;
-	std::vector<uint16_t> grData_;
-	std::vector<uint16_t> gbData_;
-	std::vector<uint16_t> bData_;
-
+	struct Components {
+		uint32_t ct;
+		std::vector<uint16_t> r;
+		std::vector<uint16_t> gr;
+		std::vector<uint16_t> gb;
+		std::vector<uint16_t> b;
+	};
+
+	void setParameters(rkisp1_params_cfg *params);
+	void copyTable(rkisp1_cif_isp_lsc_config &config, const Components &set0);
+	void interpolateTable(rkisp1_cif_isp_lsc_config &config,
+			      const Components &set0, const Components &set1,
+			      const uint32_t ct);
+
+	std::map<uint32_t, Components> sets_;
 	std::vector<double> xSize_;
 	std::vector<double> ySize_;
 	uint16_t xGrad_[RKISP1_CIF_ISP_LSC_SECTORS_TBL_SIZE];
 	uint16_t yGrad_[RKISP1_CIF_ISP_LSC_SECTORS_TBL_SIZE];
 	uint16_t xSizes_[RKISP1_CIF_ISP_LSC_SECTORS_TBL_SIZE];
 	uint16_t ySizes_[RKISP1_CIF_ISP_LSC_SECTORS_TBL_SIZE];
+	struct {
+		uint32_t original;
+		uint32_t adjusted;
+	} lastCt_;
 };
 
 } /* namespace ipa::rkisp1::algorithms */