From patchwork Tue May 5 16:11:10 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 26637 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 CCE42C32F7 for ; Tue, 5 May 2026 16:11:28 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 8FE0163030; Tue, 5 May 2026 18:11:25 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="XxBerSDd"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 35B2762DC4 for ; Tue, 5 May 2026 18:11:22 +0200 (CEST) Received: from [192.168.1.83] (unknown [IPv6:2001:b07:6462:5de2:520d:d7a3:63ca:99e8]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 69ACC874; Tue, 5 May 2026 18:11:19 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1777997479; bh=bGgqS43n/jFzC4FRyn+b3LDWNsNBrG90ma0D+MzewpQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=XxBerSDdCzJV1pYSpnLFiZ0jukAM0tEhG/eDMwJt3Y0Gq2Qk5TGUcYgIU4E9Rfoi9 ofS7BS+aqdoGC+yQMeVA490klfaofzZNhe8b3xg/9MGT3hgfwRsm7MtqA6+qF+BvzM udjzHD37AYHs/UcxjLlh/I/9MsOjI2skLN6Z7GMM= From: Jacopo Mondi Date: Tue, 05 May 2026 18:11:10 +0200 Subject: [PATCH 2/3] ipa: libipa: Introduce V4L2Stats MIME-Version: 1.0 Message-Id: <20260505-extensible-stats-v1-2-0b56c7b1bbd6@ideasonboard.com> References: <20260505-extensible-stats-v1-0-0b56c7b1bbd6@ideasonboard.com> In-Reply-To: <20260505-extensible-stats-v1-0-0b56c7b1bbd6@ideasonboard.com> To: libcamera-devel@lists.libcamera.org, Antoine Bouyer Cc: Jacopo Mondi X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=11093; i=jacopo.mondi@ideasonboard.com; h=from:subject:message-id; bh=bGgqS43n/jFzC4FRyn+b3LDWNsNBrG90ma0D+MzewpQ=; b=owEBbQKS/ZANAwAKAXI0Bo8WoVY8AcsmYgBp+hao6oHk4Q0wT5k+uW0q371es/KGiYotaP0zx pvxL2VkZLWJAjMEAAEKAB0WIQS1xD1IgJogio9YOMByNAaPFqFWPAUCafoWqAAKCRByNAaPFqFW PMfyD/9Q5CP1rsF1qHs1D8RGXESPjF2xeFar1nsF9EHUIKUZUSVbDerg5FpkrFUDFsDPEGEN6SG 8jGRVG3vjX8KLK4E4TONzzBNII/95i79h9c8YDLwKFMsVh8dUrC2d+pMrZpwdDLiIPapYFeXYVJ smQDu4BB97zuI29qbrhA36tEzff4mKROgENyAEZkWcW30df86MePanqChhcGCqKBxqNHIRrHoe2 gt7yhI6O+/fGYrt8TMfHDsj8LE6E/7xir+OwfQ6Tg+yIEoD8/0q31Z6imL0mrXCmLxN3mKyTKEL Y/MdBptLGZP2r5JlURpkKFcVkvGKeVa3CUQXM++U2Lx/dZtR6hGZSEFyanvTm9hzEUSfg9m8JCo 1gILq5Xm3RZB80Syn7pFDowIw8nPxZMLUQPuZjtgxiVNh69CADlV40ndwmCW91KkUpnCY6Ss83D N91Q2fn7K4CK/wkXaTkGILE0hmNSNVGQmuna9/H3aFiXUNr+YoJQWSFHphVRJHqyEa6k0W2qlNX BDvXp8H5FCx2SBQ9QYB1RztZCaBVCEQ5oOmI1H4mVYFE/rruks9hdMwTwFusiyhtaTTx8FjI45Z vAE2XDE3SK0I2DJv/u1z9M6DOA3OK6EMmdOGhG1vQlNXf5Nbp+Z72kGlvBw6y4bXmYuKHV49I+z UZb5S10S280YEsg== X-Developer-Key: i=jacopo.mondi@ideasonboard.com; a=openpgp; fpr=72392EDC88144A65C701EA9BA5826A2587AD026B 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 V4L2Stats class similar in spirit to the existing V4L2Params class to allow IPA modules to easily sub-class it to access ISP statistics blocks serialized into a v4l2_isp_buffer. Signed-off-by: Jacopo Mondi --- src/ipa/libipa/meson.build | 2 + src/ipa/libipa/v4l2_stats.cpp | 226 ++++++++++++++++++++++++++++++++++++++++++ src/ipa/libipa/v4l2_stats.h | 124 +++++++++++++++++++++++ 3 files changed, 352 insertions(+) diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build index 963c5ee73063..16f4b095f220 100644 --- a/src/ipa/libipa/meson.build +++ b/src/ipa/libipa/meson.build @@ -19,6 +19,7 @@ libipa_headers = files([ 'pwl.h', 'quantized.h', 'v4l2_params.h', + 'v4l2_stats.h', ]) libipa_sources = files([ @@ -40,6 +41,7 @@ libipa_sources = files([ 'pwl.cpp', 'quantized.cpp', 'v4l2_params.cpp', + 'v4l2_stats.cpp', ]) libipa_includes = include_directories('..') diff --git a/src/ipa/libipa/v4l2_stats.cpp b/src/ipa/libipa/v4l2_stats.cpp new file mode 100644 index 000000000000..050e2329dfa9 --- /dev/null +++ b/src/ipa/libipa/v4l2_stats.cpp @@ -0,0 +1,226 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas On Board + * + * V4L2 Statistics + */ + +#include "v4l2_stats.h" + +namespace libcamera { + +LOG_DEFINE_CATEGORY(V4L2Stats) + +namespace ipa { + +/** + * \file v4l2_stats.cpp + * \brief Helper class to handle an ISP statistics buffer compatible with + * the generic V4L2 ISP format + * + * The Linux kernel defines a generic buffer format for ISP statistics. + * The format describes a serialisation method that allows userspace to + * access statistics data from a binary buffer. + * + * The V4L2Stats class implements support the V4L2 ISP statistics buffer format + * and allows users to retrieve an ISP statistics blocks, represented as + * V4L2StatsBlock class instances. + * + * IPA implementations using this helpers should define an enumeration of ISP + * blocks supported by the IPA module and use a set of common abstraction to + * help their derived implementation of V4L2Stats translate the enumerated ISP + * block identifiers to the actual type of the statistics data as defined by + * the kernel interface. + */ + +/** + * \class V4L2StatsBlock + * \brief Helper class that represents an ISP statistics block + * + * Each ISP measurement block produces a set of statistics data whose memory + * layout is defined by the kernel interface. + * + * This class represents an ISP statistics block entry. It is constructed + * with a reference to the memory area where the statistics block is + * stored in the statistics buffer. The template parameter represents + * the underlying kernel-defined ISP statistics block type and allows its + * user to easily cast it to said type to read the statistics data. + * + * \sa V4L2Stats::block() + */ + +/** + * \fn V4L2StatsBlock::V4L2StatsBlock() + * \brief Construct a V4L2StatsBlock with memory represented by \a data + * \param[in] data The memory area where the statistics block is located + */ + +/** + * \fn V4L2StatsBlock::operator->() const + * \brief Access the statistics block casting it to the kernel-defined + * ISP block type + * + * The V4L2StatsBlock is templated with the kernel defined ISP block type. This + * function allows users to easily cast a V4L2StatsBlock to the underlying + * kernel-defined type in order to easily access the statistics data. + * + * \code{.cpp} + * + * // The kernel header defines the ISP statistics types, in example + * // struct my_isp_awb_stats_data { + * // u16 mean_r; + * // u16 mean_g; + * // u16 mean_b; + * // } + * + * template<> V4L2StatsBlock awbStats = ... + * + * u16 mean_r = awbStats->mean_r; + * u16 mean_g = awbStats->mean_g; + * u16 mean_b = awbStats->mean_b; + * + * \endcode + * + * Users of this class shall not create a V4L2StatsBlock manually but should + * use V4L2Stats::block(). + */ + +/** + * \fn V4L2StatsBlock::operator*() const + * \copydoc V4L2StatsBlock::operator->() const + */ + +/** + * \fn V4L2StatsBlock::size() const + * \brief Retrieve the size (in bytes) of the ISP statistics block, including + * the block's header + * \return The size of the stats block + */ + +/** + * \var V4L2StatsBlock::data_ + * \brief Memory area where ISP statistics have been serialized + */ + +/** + * \class V4L2Stats + * \brief Helper class that represent an ISP statistics buffer + * + * This class represents an ISP statistics buffer. It is constructed with a + * reference to the memory mapped buffer that has been dequeued from the ISP + * driver. + * + * This class is templated with the type of the enumeration of ISP blocks that + * each IPA module is expected to support. IPA modules are expected to derive + * this class by providing a 'stats_traits' type that helps the class associate + * a block type with the actual memory area that represents the ISP statistics + * block. + * + * \code{.cpp} + * + * // Define the supported ISP statistics blocks + * enum class myISPStats { + * Agc, + * Awb, + * ... + * }; + * + * // Maps the C++ enum type to the kernel enum type and concrete parameter type + * template + * struct block_type { + * }; + * + * template<> + * struct block_type { + * using type = struct my_isp_kernel_stats_type_agc; + * static constexpr kernel_enum_type blockType = MY_ISP_STATS_TYPE_AGC; + * }; + * + * template<> + * struct block_type { + * using type = struct my_isp_kernel_stats_type_awb; + * static constexpr kernel_enum_type blockType = MY_ISP_STATS_TYPE_AWB; + * }; + * + * + * // Convenience type to associate a block id to the 'block_type' overload + * struct stats_traits { + * using id_type = myISPStats; + * template using id_to_details = block_type; + * }; + * + * ... + * + * // Derive the V4L2Stats class by providing stats_traits + * class MyISPStats : public V4L2Stats + * { + * public: + * MyISPStats::MyISPStats(Span data) + * : V4L2Stats(data) + * { + * } + * }; + * + * \endcode + * + * Users of this class can then easily access an ISP statistics block as a + * V4L2StatsBlock instance. + * + * \code{.cpp} + * + * MyISPStats stats(data); + * + * auto awb = stats.block(); + * auto mean_r = awb->mean_r; + * auto mean_g = awb->mean_g; + * auto mean_b = awb->mean_b; + * \endcode + */ + +/** + * \fn V4L2Stats::V4L2Stats() + * \brief Construct an instance of V4L2Stats + * \param[in] data Reference to the v4l2-buffer memory mapped area + * \param[in] version The expected V4L2 ISP serialization format version + */ + +/** + * \fn V4L2Stats::bytesused() + * \brief Retrieve the size of the statistics buffer (in bytes) + * \return The number of bytes occupied by the ISP statistics + */ + +/** + * \fn V4L2Stats::block() const + * \brief Retrieve the location of an ISP statistics block a return it + * \return A V4L2StatsBlock instance that points to the ISP statistics block + */ + +/** + * \fn V4L2Stats::block(unsigned int blockType, size_t blockSize) const + * \brief Retrieve an ISP statistics block a returns a reference to it + * \param[in] blockType The kernel-defined ISP block identifier, used to + * identify the block header + * \param[in] blockSize The ISP statistics block size, for validation + * + * Parse the buffer of serialized statistics data and retrieve the location + * of the block with type \a blockType of size \a blockSize. + * + * IPA modules that derive the V4L2Stats class shall use this function to + * retrieve the memory area that will be used to construct a V4L2StatsBlock + * before returning it to the caller. + */ + +/** + * \var V4L2Stats::data_ + * \brief The ISP statistics buffer memory + */ + +/** + * \var V4L2Stats::used_ + * \brief The number of bytes used by the statistics buffer + */ + +} /* namespace ipa */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/v4l2_stats.h b/src/ipa/libipa/v4l2_stats.h new file mode 100644 index 000000000000..404cb606e135 --- /dev/null +++ b/src/ipa/libipa/v4l2_stats.h @@ -0,0 +1,124 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas On Board + * + * V4L2 Stats + */ + +#pragma once + +#include + +#include + +#include +#include + +namespace libcamera { + +LOG_DECLARE_CATEGORY(V4L2Stats) + +namespace ipa { + +template +class V4L2StatsBlock +{ +public: + V4L2StatsBlock(const Span data) + : data_(data) + { + } + + virtual ~V4L2StatsBlock() {} + + virtual const T *operator->() const + { + return reinterpret_cast(data_.data()); + } + + virtual const T &operator*() const + { + return *reinterpret_cast(data_.data()); + } + + size_t size() const + { + return data_.size(); + } + +protected: + Span data_; +}; + +template +class V4L2Stats +{ +public: + V4L2Stats(Span data, unsigned int version) + : data_(data) + { + struct v4l2_isp_buffer *stats = + reinterpret_cast(data_.data()); + used_ = stats->data_size; + + if (version != stats->version) + LOG(V4L2Stats, Error) + << "Unsupported v4l2-isp version: " << stats->version; + } + + size_t bytesused() const { return used_; } + + template + auto block() const + { + using Details = typename Traits::template id_to_details; + + using Type = typename Details::type; + constexpr auto kernelId = Details::blockType; + + auto data = block(kernelId, sizeof(Type)); + return V4L2StatsBlock(data); + } + +protected: + const Span block(unsigned int blockType, size_t blockSize) const + { + struct v4l2_isp_buffer *stats = + reinterpret_cast(data_.data()); + + __u8 *data = stats->data; + while (data < stats->data + stats->data_size) { + struct v4l2_isp_block_header *header = + reinterpret_cast(data); + + if (header->type != blockType) { + data += header->size; + continue; + } + + if (header->size != blockSize) { + LOG(V4L2Stats, Error) + << "Block type " << blockType + << " size mistmatch: expected " + << blockSize << " got:" + << header->size; + return {}; + } + + Span block(data, header->size); + return block; + } + + LOG(V4L2Stats, Error) << "Unsupported stats block type: " + << blockType; + + return {}; + } + + Span data_; + size_t used_; +}; + +} /* namespace ipa */ + +} /* namespace libcamera */