From patchwork Thu Jun 18 10:18:48 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 26924 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 EEAF5C328C for ; Thu, 18 Jun 2026 10:19:09 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 3140E629E0; Thu, 18 Jun 2026 12:19:08 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="k3O46RE+"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 131FF629E0 for ; Thu, 18 Jun 2026 12:18:59 +0200 (CEST) Received: from [192.168.125.177] (mob-109-113-4-199.net.vodafone.it [109.113.4.199]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 99FCC2689; Thu, 18 Jun 2026 12:18:23 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1781777904; bh=BCwNM9Uwi/BjvuMp45FftguRa2jcveo6lNW3w56Hse0=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=k3O46RE+6GcoE5KQBTuRXu5Rz1H8WMPA5laElfkRYfla8XAb86LYFrOPlI4tzOtPS kJR/0EvRsCwSHw/hLHD1ZldOoEuqz9DKNOCMAVZ7XptE2aIysSIXEVwArywEKl4dr5 Cvr5B7piygou7qyGT5XyBpF9Lp+v33y0KtYWsg+I= From: Jacopo Mondi Date: Thu, 18 Jun 2026 12:18:48 +0200 Subject: [PATCH 09/14] ipa: libipa: Introduce V4L2Stats MIME-Version: 1.0 Message-Id: <20260618-rppx1-ipa-v1-9-32337264cfcd@ideasonboard.com> References: <20260618-rppx1-ipa-v1-0-32337264cfcd@ideasonboard.com> In-Reply-To: <20260618-rppx1-ipa-v1-0-32337264cfcd@ideasonboard.com> To: =?utf-8?q?Niklas_S=C3=B6derlund?= , libcamera-devel@lists.libcamera.org Cc: Jacopo Mondi , Kieran Bingham X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=10203; i=jacopo.mondi@ideasonboard.com; h=from:subject:message-id; bh=BCwNM9Uwi/BjvuMp45FftguRa2jcveo6lNW3w56Hse0=; b=owEBbQKS/ZANAwAKAXI0Bo8WoVY8AcsmYgBqM8YKV0+6SIWv5CC9K4hkQvoXCP0MHnMbV9LuU x4/iGHqHZOJAjMEAAEKAB0WIQS1xD1IgJogio9YOMByNAaPFqFWPAUCajPGCgAKCRByNAaPFqFW PLb8D/44Ie784HDZHLCBhSOuHKrt+TGZH7J5cKy15U249Tg3vBozg+sffG7r5NTh9tle+smX0bU 5y+v/hWwPHiNq11vC8aFdK8CvEgoxhz2DFOvWIZf91MJ0qS9LeFuxBiMjCe2DG/Zw7IAFqD8917 uYNtwGDfOvKkXM3PNfpKiDdX6DtDGLkdZq3NLu6kvth7gbnFyGqY10wZgyhZONdjX5Zk7VReYxp w1c4CjwwQDnppxYX9HuLTzxg86r8xvF+WR2/JV1G7yJHt5F/oPdCD4Lh1I0lJ12G608kMi2EIpw 6wY7p94Uf4NwGTtGCzhRVMdGC9pMMyT3aF8sUnEASJ9s2DG/EtN5d/ntc5Nxq9QYwGCIArNjtXr tX+M6d0e/elvQYPzhO6RAnqiGdIEYFxOIcxHoqUdbLRRBQWEYxaLIJoqpBmRbaOoNlzfyVxhMdi d+tzAT7eCy3T723fPFOkUies6p3FUWxqRAEVlace37nfXVxTbzziTroyW3oiSyhyA81RWx9Z5tt tb0EeY4QKGVQ6EOrWMDV0h3IJtJDilDrjQpyv2ZGO0rn3y37PKTWqqLZPrhLGrG0iJzpBW6JMPX xqMhsfOKjesrNTrhJxw4dBWuIT/ODoGIBh69vKJm9nnA10VREQTvki0hA279NhQKb1tkVrEB0m6 myEsIQMj30g42kA== 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 Reviewed-by: Kieran Bingham --- src/ipa/libipa/meson.build | 2 + src/ipa/libipa/v4l2_stats.cpp | 241 ++++++++++++++++++++++++++++++++++++++++++ src/ipa/libipa/v4l2_stats.h | 67 ++++++++++++ 3 files changed, 310 insertions(+) diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build index edf8eabd8b78..635abad778e6 100644 --- a/src/ipa/libipa/meson.build +++ b/src/ipa/libipa/meson.build @@ -20,6 +20,7 @@ libipa_headers = files([ 'pwl.h', 'quantized.h', 'v4l2_params.h', + 'v4l2_stats.h', ]) libipa_sources = files([ @@ -42,6 +43,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..64f546d85069 --- /dev/null +++ b/src/ipa/libipa/v4l2_stats.cpp @@ -0,0 +1,241 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas On Board + * + * V4L2 Statistics + */ + +#include "v4l2_stats.h" + +#include + +namespace libcamera { + +namespace ipa { + +LOG_DEFINE_CATEGORY(V4L2Stats) + +/** + * \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 for the V4L2 ISP statistics buffer + * format and allows users to retrieve an ISP statistics block. + * + * IPA implementations using these helpers should define an enumeration of ISP + * blocks supported by the IPA module and use a set of common abstractions 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 V4L2StatsBase + * \brief Base class for V4L2Stats + * + * The V4L2StatsBase is an integral part of V4L2Stats. It serves as a + * container for all code that does not depend on the V4L2Stats template + * arguments, to avoid duplicate copies of inline code. + */ + +/** + * \brief Construct an instance of V4L2StatsBase + * \param[in] data Reference to the v4l2-buffer memory mapped area + * \param[in] version The ISP parameters version the implementation supports + * + * Parse the statistics buffer and construct a cache that maps the block type to + * the memory location of the statistics block in the buffer. + * + * After construction users of this class shall check the validity of the + * constructed instance using operator bool(). + */ +V4L2StatsBase::V4L2StatsBase(Span data, unsigned int version) + : data_(data), valid_(false) +{ + const struct v4l2_isp_buffer *stats = + reinterpret_cast(data_.data()); + + if (data_.size() - sizeof(*stats) < stats->data_size) { + LOG(V4L2Stats, Error) + << "Stats buffer size mismatch: " << stats->data_size; + return; + } + + if (version != stats->version) { + LOG(V4L2Stats, Error) + << "Unsupported v4l2-isp version: " << stats->version; + return; + } + + /* Construct the cache for easier lookup. */ + size_t left = stats->data_size; + const __u8 *d = stats->data; + + while (left > 0) { + const struct v4l2_isp_block_header *header = + reinterpret_cast(d); + + if (left < sizeof(*header) || header->size < sizeof(*header)) { + LOG(V4L2Stats, Error) + << "Block type " << header->type + << " size is not valid"; + return; + } + + if (left < header->size) { + LOG(V4L2Stats, Error) + << "Not enough space for block type " << header->type; + return; + } + + auto [it, inserted] = cache_.try_emplace(header->type, d, header->size); + if (!inserted) { + LOG(V4L2Stats, Error) + << "Duplicated block type " << header->type; + return; + } + + d += header->size; + left -= header->size; + } + + valid_ = true; +} + +/** + * \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 + * + * Retrieve a span to the statistics block memory location by accessing the + * cache built at class construction time. + * + * \return The memory location of the ISP statistics block, or an empty Span + * if \a blockType is not supported + */ +Span V4L2StatsBase::block(unsigned int blockType, size_t blockSize) const +{ + const auto it = cache_.find(blockType); + if (it == cache_.end()) { + LOG(V4L2Stats, Error) << "Unsupported stats block type: " + << blockType; + return {}; + } + + const struct v4l2_isp_block_header *header = + reinterpret_cast(it->second.data()); + if (header->size != blockSize) { + LOG(V4L2Stats, Error) + << "Block type " << blockType + << " size mistmatch: expected " + << blockSize << " got:" + << header->size; + return {}; + } + + return it->second; +} + +/** + * \fn V4L2StatsBase::operator bool() + * \brief Retrieve if a statistics block is valid + * \return True if the statistics block is valid, false otherwise + */ + +/** + * \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, unsigned int version) + * : V4L2Stats(data, version) + * { + * } + * }; + * + * \endcode + * + * Users of this class can then easily access an ISP statistics block using the + * block() function. + * + * \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::block() const + * \brief Retrieve a pointer to an ISP statistics block + * \return A pointer to the ISP statistics block + */ + +} /* 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..b96395e5f551 --- /dev/null +++ b/src/ipa/libipa/v4l2_stats.h @@ -0,0 +1,67 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas On Board + * + * V4L2 ISP Statistics + */ + +#pragma once + +#include +#include + +#include + +#include + +namespace libcamera { + +namespace ipa { + +class V4L2StatsBase +{ +public: + V4L2StatsBase(Span data, unsigned int version); + + Span block(unsigned int blockType, size_t blockSize) const; + constexpr explicit operator bool() + { + return valid_; + } + +private: + std::map> cache_; + Span data_; + bool valid_; +}; + +template +class V4L2Stats : public V4L2StatsBase +{ +public: + static_assert(std::is_same_v, uint16_t>); + + V4L2Stats(Span data, unsigned int version) + : V4L2StatsBase(data, version) + { + } + + template + const typename Traits::template id_to_details::type * + block() const + { + using Details = typename Traits::template id_to_details; + + using Type = typename Details::type; + constexpr auto kernelId = Details::blockType; + + auto data = V4L2StatsBase::block(kernelId, sizeof(Type)); + + return data.size() > 0 ? + reinterpret_cast(data.data()) : nullptr; + } +}; + +} /* namespace ipa */ + +} /* namespace libcamera */