From patchwork Tue Jun 11 14:02:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 20261 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 34B54C31E9 for ; Tue, 11 Jun 2024 14:02:34 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id DA6AB6546C; Tue, 11 Jun 2024 16:02:33 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="SVRF4ACs"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 4261261A26 for ; Tue, 11 Jun 2024 16:02:24 +0200 (CEST) Received: from neptunite.hamster-moth.ts.net (h175-177-049-156.catv02.itscom.jp [175.177.49.156]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 39888E0C; Tue, 11 Jun 2024 16:02:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1718114531; bh=6SkWhaVo8yh2kxVL49xg198Jfjk9xEEAb6+rbG6pks8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SVRF4ACsbbH4JyOv3uqn4iG8P6Q3qwGCd9u+uE+xOMGp+bWtqjNwQFej3Z9f0pd2G rv972JsFbOFj0NKy9ST388vEA8gD3hac695P+ydpRh+6+g8FOB8A86BEkXnFz3xehe ySTJKjOAMB/+vjBL9BGsX/NWcK4M4KO+gfjAeHwA= From: Paul Elder To: libcamera-devel@lists.libcamera.org Cc: Paul Elder , Stefan Klug , Kieran Bingham Subject: [PATCH v7 1/3] ipa: libipa: Add Matrix class Date: Tue, 11 Jun 2024 23:02:05 +0900 Message-Id: <20240611140207.520083-2-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240611140207.520083-1-paul.elder@ideasonboard.com> References: <20240611140207.520083-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a class to represent a Matrix object and operations for adding matrices, multipling a matrix by a scalar, and multiplying two matrices. Signed-off-by: Paul Elder Reviewed-by: Stefan Klug Reviewed-by: Kieran Bingham --- Changes in v7: - fix copyright and license Changes in v6: - fix doxygen Changes in v5: - add documentation Changes in v4: - remove stray semicolons - add operator<< - clean up/optimize constructor - replace get() and set() with operator[] (and a second [] can be used as operator[] returns a Span) Changes in v3: - fix template parameters of operator* to allow different types for the scalar multiplier and the matrix's number type - clear data in constructors - fix assert in constructor Changes v2: - make rows and columns into template arguments - initialize to identity matrix on construction - add getter and setter - change from struct to class - fix matrix multiplication - clean up unused includes - avoid dereferencing an absent std::optional --- src/ipa/libipa/matrix.cpp | 123 ++++++++++++++++++++++++++ src/ipa/libipa/matrix.h | 172 +++++++++++++++++++++++++++++++++++++ src/ipa/libipa/meson.build | 2 + 3 files changed, 297 insertions(+) create mode 100644 src/ipa/libipa/matrix.cpp create mode 100644 src/ipa/libipa/matrix.h diff --git a/src/ipa/libipa/matrix.cpp b/src/ipa/libipa/matrix.cpp new file mode 100644 index 000000000000..02091a0b4ce1 --- /dev/null +++ b/src/ipa/libipa/matrix.cpp @@ -0,0 +1,123 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Matrix and related operations + */ + +#include "matrix.h" + +#include + +/** + * \file matrix.h + * \brief Matrix class + */ + +namespace libcamera { + +LOG_DEFINE_CATEGORY(Matrix) + +namespace ipa { + +/** + * \class Matrix + * \brief Matrix class + * \tparam T Type of numerical values to be stored in the matrix + * \tparam R Number of rows in the matrix + * \tparam C Number of columns in the matrix + */ + +/** + * \fn Matrix::Matrix() + * \brief Construct an identity matrix + */ + +/** + * \fn Matrix::Matrix(const std::vector &data) + * \brief Construct matrix from supplied data + * \param data Data from which to construct a matrix + * + * \a data is a one-dimensional vector and will be turned into a matrix in + * row-major order. The size of \a data must be equal to the product of the + * number of rows and columns of the matrix (RxC). + */ + +/** + * \fn Matrix::readYaml + * \brief Populate the matrix with yaml data + * \param yaml Yaml data to populate the matrix with + * + * Any existing data in the matrix will be overwritten. The size of the data + * read from \a yaml must be equal to the product of the number of rows and + * columns of the matrix (RxC). + * + * The yaml data is expected to be a list with elements of type T. + * + * \return 0 on success, negative error code otherwise + */ + +/** + * \fn Matrix::toString + * \brief Assemble and return a string describing the matrix + * \return A string describing the matrix + */ + +/** + * \fn Span Matrix::operator[](size_t i) const + * \brief Index to a row in the matrix + * \param i Index of row to retrieve + * + * This operator[] returns a Span, which can then be indexed into again with + * another operator[], allowing a convenient m[i][j] to access elements of the + * matrix. Note that the lifetime of the Span returned by this first-level + * operator[] is bound to that of the Matrix itself, so it is not recommended + * to save the Span that is the result of this operator[]. + * + * \return Row \a i from the matrix, as a Span + */ + +/** + * \fn Matrix::operator[](size_t i) + * \copydoc Matrix::operator[](size_t i) const + */ + +/** + * \fn Matrix::Matrix operator*(T d, const Matrix &m) + * \brief Scalar product + * \tparam T Type of the numerical scalar value + * \tparam U Type of numerical values in the matrix + * \tparam R Number of rows in the matrix + * \tparam C Number of columns in the matrix + * \param d Scalar + * \param m Matrix + * \return Product of scalar \a d and matrix \a m + */ + +/** + * \fn Matrix operator*(const Matrix &m1, const Matrix &m2) + * \brief Matrix multiplication + * \tparam T Type of numerical values in the matrices + * \tparam R1 Number of rows in the first matrix + * \tparam C1 Number of columns in the first matrix + * \tparam R2 Number of rows in the second matrix + * \tparam C2 Number of columns in the second matrix + * \param m1 Multiplicand matrix + * \param m2 Multiplier matrix + * \return Matrix product of matrices \a m1 and \a m2 + */ + +/** + * \fn Matrix operator+(const Matrix &m1, const Matrix &m2) + * \brief Matrix addition + * \tparam T Type of numerical values in the matrices + * \tparam R Number of rows in the matrices + * \tparam C Number of columns in the matrices + * \param m1 Summand matrix + * \param m2 Summand matrix + * \return Matrix sum of matrices \a m1 and \a m2 + */ + +} /* namespace ipa */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/matrix.h b/src/ipa/libipa/matrix.h new file mode 100644 index 000000000000..90eaea03bd14 --- /dev/null +++ b/src/ipa/libipa/matrix.h @@ -0,0 +1,172 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Matrix and related operations + */ +#pragma once + +#include +#include +#include +#include + +#include +#include + +#include "libcamera/internal/yaml_parser.h" + +namespace libcamera { + +LOG_DECLARE_CATEGORY(Matrix) + +namespace ipa { + +#ifndef __DOXYGEN__ +template> * = nullptr> +#else +template +#endif /* __DOXYGEN__ */ +class Matrix +{ +public: + Matrix() + : data_(R * C, static_cast(false)) + { + for (size_t i = 0; i < std::min(R, C); i++) + (*this)[i][i] = static_cast(true); + } + + Matrix(const std::vector &data) + { + ASSERT(data.size() == R * C); + + data_.clear(); + for (const T &x : data) + data_.push_back(x); + } + + ~Matrix() = default; + + int readYaml(const libcamera::YamlObject &yaml) + { + if (yaml.size() != R * C) { + LOG(Matrix, Error) + << "Wrong number of values in matrix: expected " + << R * C << ", got " << yaml.size(); + return -EINVAL; + } + + unsigned int i = 0; + for (const auto &x : yaml.asList()) { + auto value = x.get(); + if (!value) { + LOG(Matrix, Error) << "Failed to read matrix value"; + return -EINVAL; + } + + data_[i++] = *value; + } + + return 0; + } + + const std::string toString() const + { + std::stringstream out; + + out << "Matrix { "; + for (unsigned int i = 0; i < R; i++) { + out << "[ "; + for (unsigned int j = 0; j < C; j++) { + out << (*this)[i][j]; + out << ((j + 1 < C) ? ", " : " "); + } + out << ((i + 1 < R) ? "], " : "]"); + } + out << " }"; + + return out.str(); + } + + Span operator[](size_t i) const + { + return Span{ &data_.data()[i * C], C }; + } + + Span operator[](size_t i) + { + return Span{ &data_.data()[i * C], C }; + } + +private: + std::vector data_; +}; + +#ifndef __DOXYGEN__ +template && std::is_arithmetic_v> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator*(T d, const Matrix &m) +{ + Matrix result; + + for (unsigned int i = 0; i < R; i++) + for (unsigned int j = 0; j < C; j++) + result[i][j] = d * m[i][j]; + + return result; +} + +#ifndef __DOXYGEN__ +template && C1 == R2> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator*(const Matrix &m1, const Matrix &m2) +{ + Matrix result; + + for (unsigned int i = 0; i < R1; i++) { + for (unsigned int j = 0; j < C2; j++) { + T sum = 0; + + for (unsigned int k = 0; k < C1; k++) + sum += m1[i][k] * m2[k][j]; + + result[i][j] = sum; + } + } + + return result; +} + +#ifndef __DOXYGEN__ +template> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator+(const Matrix &m1, const Matrix &m2) +{ + Matrix result; + + for (unsigned int i = 0; i < R; i++) + for (unsigned int j = 0; j < C; j++) + result[i][j] = m1[i][j] + m2[i][j]; + + return result; +} + +} /* namespace ipa */ + +#ifndef __DOXYGEN__ +template +std::ostream &operator<<(std::ostream &out, const ipa::Matrix &m) +{ + out << m.toString(); + return out; +} +#endif /* __DOXYGEN__ */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build index b663afc7d9fe..067d0d273e0a 100644 --- a/src/ipa/libipa/meson.build +++ b/src/ipa/libipa/meson.build @@ -7,6 +7,7 @@ libipa_headers = files([ 'exposure_mode_helper.h', 'fc_queue.h', 'histogram.h', + 'matrix.h', 'module.h', ]) @@ -17,6 +18,7 @@ libipa_sources = files([ 'exposure_mode_helper.cpp', 'fc_queue.cpp', 'histogram.cpp', + 'matrix.cpp', 'module.cpp', ]) From patchwork Tue Jun 11 14:02:06 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 20262 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 7447AC31E9 for ; Tue, 11 Jun 2024 14:02:36 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 76A2E65467; Tue, 11 Jun 2024 16:02:35 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="Y8JXvbfX"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 9967761A26 for ; Tue, 11 Jun 2024 16:02:27 +0200 (CEST) Received: from neptunite.hamster-moth.ts.net (h175-177-049-156.catv02.itscom.jp [175.177.49.156]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id B99ACA9A; Tue, 11 Jun 2024 16:02:12 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1718114535; bh=CYJUi4wDok7KNAf1uQEw5+nTNhwWVlZrEobSxyp4E8s=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Y8JXvbfXG61SYW9tXxG9VtwtBYxF+aiF8SCV6XYSQ1nb19bJ5j0C6zVLtynvUPdlS 6kLohgYx2Oi0FAfkKLhVD8YxTbc/8Z/b6WqB8ptgxs6Dsh76uZ1UgKhRrKxF46g86n 2JOsDRtHVYho8e6+Ulsig06vVjP+1fUx6dfv7ECs= From: Paul Elder To: libcamera-devel@lists.libcamera.org Cc: Paul Elder , Stefan Klug Subject: [PATCH v7 2/3] ipa: libipa: Add MatrixInterpolator class Date: Tue, 11 Jun 2024 23:02:06 +0900 Message-Id: <20240611140207.520083-3-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240611140207.520083-1-paul.elder@ideasonboard.com> References: <20240611140207.520083-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a class to encapsulate the functionality of fetching a matrix based on an integer key, and interpolating if there is no exact match. This is expected to be used by both color correction matrices / crosstalk correction as well as lens shading correction. A cache is included only for exact matches of the key. The caller is expected to decide the tolererance for rounding. Signed-off-by: Paul Elder Reviewed-by: Stefan Klug Reviewed-by: Kieran Bingham --- Changes in v7: - remove cache - fix copyright and license Changes in v6: - fix doxygen Changes in v5: - improve documentation - replace count() with find() != end() (in get()) - add cache Changes in v4: - remove stray semicolons - read from the new yaml layout (which mirrors what we have at the moment for lsc), and add keys to make it more flexible Changes in v3: - add a constructor that takes a map of unsigned int -> matrix - s/unit/identity - clear matrices on reset and when reading from yaml - add assert at get() Changes in v2: - initialize to identity matrix - add a function to reset to identity matrix - other minor fixes --- src/ipa/libipa/matrix_interpolator.cpp | 110 ++++++++++++++++++++++ src/ipa/libipa/matrix_interpolator.h | 124 +++++++++++++++++++++++++ src/ipa/libipa/meson.build | 2 + 3 files changed, 236 insertions(+) create mode 100644 src/ipa/libipa/matrix_interpolator.cpp create mode 100644 src/ipa/libipa/matrix_interpolator.h diff --git a/src/ipa/libipa/matrix_interpolator.cpp b/src/ipa/libipa/matrix_interpolator.cpp new file mode 100644 index 000000000000..04ca177f72c6 --- /dev/null +++ b/src/ipa/libipa/matrix_interpolator.cpp @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Helper class for interpolating maps of matrices + */ +#include "matrix_interpolator.h" + +#include +#include + +#include + +#include "libcamera/internal/yaml_parser.h" + +#include "matrix.h" + +/** + * \file matrix_interpolator.h + * \brief Helper class for interpolating maps of matrices + */ + +namespace libcamera { + +LOG_DEFINE_CATEGORY(MatrixInterpolator) + +namespace ipa { + +/** + * \class MatrixInterpolator + * \brief Class for storing, retrieving, and interpolating matrices + * \tparam T Type of numerical values to be stored in the matrices + * \tparam R Number of rows in the matrices + * \tparam C Number of columns in the matrices + * + * The main use case is to pass a map from color temperatures to corresponding + * matrices (eg. color correction), and then requesting a matrix for a specific + * color temperature. This class will abstract away the interpolation portion. + */ + +/** + * \fn MatrixInterpolator::MatrixInterpolator(const std::map> &matrices) + * \brief Construct a matrix interpolator from a map of matrices + * \param matrices Map from which to construct the matrix interpolator + */ + +/** + * \fn MatrixInterpolator::reset() + * \brief Reset the matrix interpolator content to a single identity matrix + */ + +/** + * \fn int MatrixInterpolator::readYaml() + * \brief Initialize an MatrixInterpolator instance from yaml + * \tparam T Type of data stored in the matrices + * \tparam R Number of rows of the matrices + * \tparam C Number of columns of the matrices + * \param[in] yaml The yaml object that contains the map of unsigned integers to matrices + * \param[in] key_name The name of the key in the yaml object + * \param[in] matrix_name The name of the matrix in the yaml object + * + * The yaml object is expected to be a list of maps. Each map has two or more + * pairs: one of \a key_name to the key value (usually color temperature), and + * one or more of \a matrix_name to the matrix. This is a bit difficult to + * explain, so here is an example (in python, as it is easier to parse than + * yaml): + * [ + * { + * 'ct': 2860, + * 'ccm': [ 2.12089, -0.52461, -0.59629, + * -0.85342, 2.80445, -0.95103, + * -0.26897, -1.14788, 2.41685 ], + * 'offsets': [ 0, 0, 0 ] + * }, + * + * { + * 'ct': 2960, + * 'ccm': [ 2.26962, -0.54174, -0.72789, + * -0.77008, 2.60271, -0.83262, + * -0.26036, -1.51254, 2.77289 ], + * 'offsets': [ 0, 0, 0 ] + * }, + * + * { + * 'ct': 3603, + * 'ccm': [ 2.18644, -0.66148, -0.52496, + * -0.77828, 2.69474, -0.91645, + * -0.25239, -0.83059, 2.08298 ], + * 'offsets': [ 0, 0, 0 ] + * }, + * ] + * + * In this case, \a key_name would be 'ct', and \a matrix_name can be either + * 'ccm' or 'offsets'. This way multiple matrix interpolators can be defined in + * one set of color temperature ranges in the tuning file, and they can be + * retrieved separately with the \a matrix_name parameter. + * + * \return Zero on success, negative error code otherwise + */ + +/** + * \fn Matrix MatrixInterpolator::get(unsigned int key) + * \brief Retrieve a matrix from the list of matrices, interpolating if necessary + * \param[in] key The unsigned integer key of the matrix to retrieve + * \return The matrix corresponding to the color temperature + */ + +} /* namespace ipa */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/matrix_interpolator.h b/src/ipa/libipa/matrix_interpolator.h new file mode 100644 index 000000000000..36827faec9ae --- /dev/null +++ b/src/ipa/libipa/matrix_interpolator.h @@ -0,0 +1,124 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Helper class for interpolating maps of matrices + */ + +#pragma once + +#include +#include +#include +#include + +#include + +#include "libcamera/internal/yaml_parser.h" + +#include "matrix.h" + +namespace libcamera { + +LOG_DECLARE_CATEGORY(MatrixInterpolator) + +namespace ipa { + +#ifndef __DOXYGEN__ +template> * = nullptr> +#else +template +#endif /* __DOXYGEN__ */ +class MatrixInterpolator +{ +public: + MatrixInterpolator() + { + reset(); + } + + MatrixInterpolator(const std::map> &matrices) + { + for (const auto &pair : matrices) + matrices_[pair.first] = pair.second; + } + + ~MatrixInterpolator() {} + + void reset() + { + Matrix identity; + matrices_.clear(); + matrices_[0] = identity; + } + + int readYaml(const libcamera::YamlObject &yaml, + const std::string &key_name, + const std::string &matrix_name) + { + int ret; + + matrices_.clear(); + + if (!yaml.isList()) { + LOG(MatrixInterpolator, Error) << "yaml object must be a list"; + return -EINVAL; + } + + for (const auto &value : yaml.asList()) { + unsigned int ct = std::stoul(value[key_name].get("")); + Matrix matrix; + if ((ret = matrix.readYaml(value[matrix_name])) < 0) { + LOG(MatrixInterpolator, Error) << "Failed to read matrix"; + return ret; + } + + matrices_[ct] = matrix; + + LOG(MatrixInterpolator, Debug) + << "Read matrix '" << matrix_name << "' for key '" + << key_name << "' " << ct << ": " + << matrices_[ct].toString(); + } + + if (matrices_.size() < 1) { + LOG(MatrixInterpolator, Error) << "Need at least one matrix"; + return -EINVAL; + } + + return 0; + } + + Matrix get(unsigned int ct) + { + ASSERT(matrices_.size() > 0); + + if (matrices_.size() == 1 || + ct <= matrices_.begin()->first) + return matrices_.begin()->second; + + if (ct >= matrices_.rbegin()->first) + return matrices_.rbegin()->second; + + if (matrices_.find(ct) != matrices_.end()) + return matrices_[ct]; + + /* The above four guarantee that this will succeed */ + auto iter = matrices_.upper_bound(ct); + unsigned int ctUpper = iter->first; + unsigned int ctLower = (--iter)->first; + + double lambda = (ct - ctLower) / static_cast(ctUpper - ctLower); + Matrix ret = + lambda * matrices_[ctUpper] + (1.0 - lambda) * matrices_[ctLower]; + return ret; + } + +private: + std::map> matrices_; +}; + +} /* namespace ipa */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build index 067d0d273e0a..a3349f0dd2c2 100644 --- a/src/ipa/libipa/meson.build +++ b/src/ipa/libipa/meson.build @@ -8,6 +8,7 @@ libipa_headers = files([ 'fc_queue.h', 'histogram.h', 'matrix.h', + 'matrix_interpolator.h', 'module.h', ]) @@ -19,6 +20,7 @@ libipa_sources = files([ 'fc_queue.cpp', 'histogram.cpp', 'matrix.cpp', + 'matrix_interpolator.cpp', 'module.cpp', ]) From patchwork Tue Jun 11 14:02:07 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 20263 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 23D77C3292 for ; Tue, 11 Jun 2024 14:02:38 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id D8CFD65463; Tue, 11 Jun 2024 16:02:36 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="qZJVTOQO"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 9DCB661A26 for ; Tue, 11 Jun 2024 16:02:31 +0200 (CEST) Received: from neptunite.hamster-moth.ts.net (h175-177-049-156.catv02.itscom.jp [175.177.49.156]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id C3B0329A; Tue, 11 Jun 2024 16:02:15 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1718114539; bh=1OOlzXMAZ/zuHGpZMsthYsCwiyfM/2we0+4WD2qJNn4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=qZJVTOQO6V8oH68vNNYGypr4nRv3MWxxKcWkR85vrpwzz3QBZkZiFTmwP/qjfvK9f 4E/kJ3JaxqJp0omwJlL+JMgrn0KW+rsBpgpolR9sDaSIe3GACqi+XMAnJeb7c6iyUA N2vYKXYpg4uGz+HgOKYRN5fH+kumY4yFFKe1iOIM= From: Paul Elder To: libcamera-devel@lists.libcamera.org Cc: Paul Elder , Stefan Klug Subject: [PATCH v7 3/3] ipa: rkisp1: algorithms: Add crosstalk algorithm Date: Tue, 11 Jun 2024 23:02:07 +0900 Message-Id: <20240611140207.520083-4-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240611140207.520083-1-paul.elder@ideasonboard.com> References: <20240611140207.520083-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add an algorithm module to the rkisp1 IPA for crosstalk correction. Signed-off-by: Paul Elder Reviewed-by: Stefan Klug Reviewed-by: Kieran Bingham Reviewed-by: Kieran Bingham --- Changes in v7: - make offsets_ default to zero-matrices as opposed to identity matrices - checkstyle - populate metadata - add ccm to IPAFrameContext - don't update the ccm if the color temperature didn't change No change in v6 Changes in v5: - clean up documentation - coalesce parseYaml into init Changes in v4: - remove stray semicolons - use the new matrix interpolator readYaml - use the new matrix operator[] getter Changes in v3: - read ccm offsets from tuning data, and write these offsets to the parameters buffer - make parseYaml return void, as it should fill in default data if unable to read, thus never failing Changes in v2: - rename ctk to ccm - reset the matrix interpolator to identity matrix if failed to read from tuning file --- src/ipa/rkisp1/algorithms/ccm.cpp | 140 ++++++++++++++++++++++++++ src/ipa/rkisp1/algorithms/ccm.h | 50 +++++++++ src/ipa/rkisp1/algorithms/meson.build | 1 + src/ipa/rkisp1/ipa_context.h | 5 + 4 files changed, 196 insertions(+) create mode 100644 src/ipa/rkisp1/algorithms/ccm.cpp create mode 100644 src/ipa/rkisp1/algorithms/ccm.h diff --git a/src/ipa/rkisp1/algorithms/ccm.cpp b/src/ipa/rkisp1/algorithms/ccm.cpp new file mode 100644 index 000000000000..09fe4b2aa1bc --- /dev/null +++ b/src/ipa/rkisp1/algorithms/ccm.cpp @@ -0,0 +1,140 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Ideas On Board + * + * RkISP1 Color Correction Matrix control algorithm + */ + +#include "ccm.h" + +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include + +#include "libcamera/internal/yaml_parser.h" + +#include "../utils.h" +#include "libipa/matrix_interpolator.h" + +/** + * \file ccm.h + */ + +namespace libcamera { + +namespace ipa::rkisp1::algorithms { + +/** + * \class Ccm + * \brief A color correction matrix algorithm + */ + +LOG_DEFINE_CATEGORY(RkISP1Ccm) + +/** + * \copydoc libcamera::ipa::Algorithm::init + */ +int Ccm::init([[maybe_unused]] IPAContext &context, const YamlObject &tuningData) +{ + int ret = ccm_.readYaml(tuningData["ccms"], "ct", "ccm"); + if (ret < 0) { + LOG(RkISP1Ccm, Warning) + << "Failed to parse 'ccm' " + << "parameter from tuning file; falling back to unit matrix"; + ccm_.reset(); + } + + ret = offsets_.readYaml(tuningData["ccms"], "ct", "offsets"); + if (ret < 0) { + LOG(RkISP1Ccm, Warning) + << "Failed to parse 'offsets' " + << "parameter from tuning file; falling back to zero offsets"; + /* + * MatrixInterpolator::reset() resets to identity matrices + * while here we need zero matrices so we need to construct it + * ourselves. + */ + Matrix m({ 0, 0, 0 }); + std::map> matrices = { { 0, m } }; + offsets_ = MatrixInterpolator(matrices); + } + + return 0; +} + +void Ccm::setParameters(rkisp1_params_cfg *params, + const Matrix &matrix, + const Matrix &offsets) +{ + struct rkisp1_cif_isp_ctk_config &config = params->others.ctk_config; + + /* + * 4 bit integer and 7 bit fractional, ranging from -8 (0x400) to + * +7.992 (0x3ff) + */ + for (unsigned int i = 0; i < 3; i++) + for (unsigned int j = 0; j < 3; j++) + config.coeff[i][j] = + utils::floatingToFixedPoint<4, 7, uint16_t, double>(matrix[i][j]); + + for (unsigned int i = 0; i < 3; i++) + config.ct_offset[i] = offsets[i][0] & 0xfff; + + LOG(RkISP1Ccm, Debug) << "Setting matrix " << matrix; + LOG(RkISP1Ccm, Debug) << "Setting offsets " << offsets; + + params->module_en_update |= RKISP1_CIF_ISP_MODULE_CTK; + params->module_ens |= RKISP1_CIF_ISP_MODULE_CTK; + params->module_cfg_update |= RKISP1_CIF_ISP_MODULE_CTK; +} + +/** + * \copydoc libcamera::ipa::Algorithm::prepare + */ +void Ccm::prepare(IPAContext &context, [[maybe_unused]] const uint32_t frame, + IPAFrameContext &frameContext, + rkisp1_params_cfg *params) +{ + uint32_t ct = context.activeState.awb.temperatureK; + if (ct == ct_) + return; + + ct_ = ct; + Matrix ccm = ccm_.get(ct); + Matrix offsets = offsets_.get(ct); + + frameContext.ccm.ccm = ccm; + + setParameters(params, ccm, offsets); +} + +/** + * \copydoc libcamera::ipa::Algorithm::process + */ +void process([[maybe_unused]] IPAContext &context, + [[maybe_unused]] const uint32_t frame, + IPAFrameContext &frameContext, + [[maybe_unused]] const rkisp1_stat_buffer *stats, + ControlList &metadata) +{ + float m[9]; + for (unsigned int i = 0; i < 3; i++) + for (unsigned int j = 0; j < 3; j++) + m[i] = frameContext.ccm.ccm[i][j]; + metadata.set(controls::ColourCorrectionMatrix, m); +} + +REGISTER_IPA_ALGORITHM(Ccm, "Ccm") + +} /* namespace ipa::rkisp1::algorithms */ + +} /* namespace libcamera */ diff --git a/src/ipa/rkisp1/algorithms/ccm.h b/src/ipa/rkisp1/algorithms/ccm.h new file mode 100644 index 000000000000..09a6801626b4 --- /dev/null +++ b/src/ipa/rkisp1/algorithms/ccm.h @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Ideas On Board + * + * RkISP1 Color Correction Matrix control algorithm + */ + +#pragma once + +#include + +#include "libipa/matrix.h" +#include "libipa/matrix_interpolator.h" + +#include "algorithm.h" + +namespace libcamera { + +namespace ipa::rkisp1::algorithms { + +class Ccm : public Algorithm +{ +public: + Ccm() {} + ~Ccm() = default; + + int init(IPAContext &context, const YamlObject &tuningData) override; + void prepare(IPAContext &context, const uint32_t frame, + IPAFrameContext &frameContext, + rkisp1_params_cfg *params) override; + void process([[maybe_unused]] IPAContext &context, + [[maybe_unused]] const uint32_t frame, + IPAFrameContext &frameContext, + [[maybe_unused]] const rkisp1_stat_buffer *stats, + ControlList &metadata) override; + +private: + void parseYaml(const YamlObject &tuningData); + void setParameters(rkisp1_params_cfg *params, + const Matrix &matrix, + const Matrix &offsets); + + unsigned int ct_; + MatrixInterpolator ccm_; + MatrixInterpolator offsets_; +}; + +} /* namespace ipa::rkisp1::algorithms */ + +} /* namespace libcamera */ diff --git a/src/ipa/rkisp1/algorithms/meson.build b/src/ipa/rkisp1/algorithms/meson.build index 6ee71a9b5da3..1734a6675f78 100644 --- a/src/ipa/rkisp1/algorithms/meson.build +++ b/src/ipa/rkisp1/algorithms/meson.build @@ -4,6 +4,7 @@ rkisp1_ipa_algorithms = files([ 'agc.cpp', 'awb.cpp', 'blc.cpp', + 'ccm.cpp', 'cproc.cpp', 'dpcc.cpp', 'dpf.cpp', diff --git a/src/ipa/rkisp1/ipa_context.h b/src/ipa/rkisp1/ipa_context.h index 2a994d81ae41..cfb1f9770870 100644 --- a/src/ipa/rkisp1/ipa_context.h +++ b/src/ipa/rkisp1/ipa_context.h @@ -16,6 +16,7 @@ #include #include +#include namespace libcamera { @@ -155,6 +156,10 @@ struct IPAFrameContext : public FrameContext { uint32_t exposure; double gain; } sensor; + + struct { + Matrix ccm; + } ccm; }; struct IPAContext {