From 14c869c00fdd79a93d06b506546051716a2f4623 Mon Sep 17 00:00:00 2001 From: Florian Sylvestre Date: Mon, 3 Oct 2022 16:23:57 +0200 Subject: 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 Signed-off-by: Paul Elder Reviewed-by: Jacopo Mondi Reviewed-by: Laurent Pinchart --- src/ipa/rkisp1/algorithms/lsc.cpp | 200 +++++++++++++++++++++++++++++++++----- src/ipa/rkisp1/algorithms/lsc.h | 26 ++++- 2 files changed, 197 insertions(+), 29 deletions(-) (limited to 'src/ipa/rkisp1/algorithms') 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 #include #include @@ -89,6 +90,7 @@ static std::vector 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(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 + #include "algorithm.h" namespace libcamera { @@ -26,17 +28,31 @@ public: rkisp1_params_cfg *params) override; private: - std::vector rData_; - std::vector grData_; - std::vector gbData_; - std::vector bData_; - + struct Components { + uint32_t ct; + std::vector r; + std::vector gr; + std::vector gb; + std::vector 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 sets_; std::vector xSize_; std::vector 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 */ -- cgit v1.2.1