[WIP,RFC,12/26] libcamera: bayer_format: Introduce a ColorFilterArray class

Message ID	20261023-b4-raw-model-v1-12-eadb9948901b@ideasonboard.com
State	New
Headers	show Return-Path: <libcamera-devel-bounces@lists.libcamera.org> From: Jai Luthra <jai.luthra@ideasonboard.com> Date: Fri, 23 Oct 2026 16:28:20 +0530 Subject: [PATCH WIP RFC 12/26] libcamera: bayer_format: Introduce a ColorFilterArray class MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20261023-b4-raw-model-v1-12-eadb9948901b@ideasonboard.com> References: <20261023-b4-raw-model-v1-0-eadb9948901b@ideasonboard.com> In-Reply-To: <20261023-b4-raw-model-v1-0-eadb9948901b@ideasonboard.com> To: libcamera-devel@lists.libcamera.org Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>, Kieran Bingham <kieran.bingham@ideasonboard.com>, Sakari Ailus <sakari.ailus@iki.fi>, Naushir Patuck <naush@raspberrypi.com>, Jai Luthra <jai.luthra@ideasonboard.com> Precedence: list Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" <libcamera-devel-bounces@lists.libcamera.org>
Series	Support the new common raw sensor model
Related	show [WIP,RFC,00/26] Support the new common raw sensor model [WIP,RFC,01/26] include: linux: Update uAPI headers to v7.3 + Common Raw Sensor Model [WIP,RFC,02/26] libcamera: v4l2_subdevice: Add mediaBusInfo for generic raw formats [WIP,RFC,03/26] libcamera: v4l2_pixelformat: Update to latest version of generic META formats [WIP,RFC,04/26] pipeline: rpi: vc4: Map subdev metadata formats to V4L2 fourcc [WIP,RFC,05/26] include: uapi: videodev2: Add formats for unpacked RAW [WIP,RFC,06/26] include: uapi: videodev2: Add RAW device-specific bayer formats [WIP,RFC,07/26] libcamera: Drop MediaBusFormatInfo::Type::EmbeddedData [WIP,RFC,08/26] libcamera: camera_sensor_raw: Read the new CFA_PATTERN control [WIP,RFC,09/26] libcamera: camera_sensor_raw: Enumerate formats using sink pads [WIP,RFC,10/26] libcamera: camera_sensor_raw: Check for CONFIG_MODEL [WIP,RFC,11/26] libcamera: Support raw sensor model [WIP,RFC,12/26] libcamera: bayer_format: Introduce a ColorFilterArray class [WIP,RFC,13/26] include: uapi: drm_fourcc: Add 14-bit R format [WIP,RFC,14/26] libcamera: formats: Switch to generic layout-agnostic formats [WIP,RFC,15/26] HACK: libcamera: formats: Add a modifier for RAW colorspace [WIP,RFC,16/26] libcamera: v4l2_pixelformat: Add toNonGeneric() helper [WIP,RFC,17/26] libcamera: bayer_format: Strip out ColorFilterArray from BayerFormat [WIP,RFC,18/26] libcamera: stream: Add bayerOrder for raw formats [WIP,RFC,19/26] libcamera: camera_sensor: Add helpers for isRaw() and isMono() [WIP,RFC,20/26] pipeline: rpi: Use CameraSensor::isMono() helper [WIP,RFC,21/26] pipeline: rpi: Split bayerOrder from PixelFormat [WIP,RFC,22/26] pipeline: rpi: Prefer generic raw formats [WIP,RFC,23/26] pipeline: rpi: pisp: Migrate to RAW formats [WIP,RFC,24/26] pipeline: rpi: vc4: Migrate to generic RAW formats [WIP,RFC,25/26] pipeline: mali-c55: Use generic RAW formats [WIP,RFC,26/26] apps: dng_writer: Split cfa pattern handling

diff --git a/include/libcamera/color_filter_array.h b/include/libcamera/color_filter_array.h new file mode 100644 index 000000000000..167a4a3ff323 --- /dev/null +++ b/include/libcamera/color_filter_array.h @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas on Board Oy + * + * Bayer Color Filter Array patterns + */ + +#pragma once + +#include <optional> +#include <ostream> +#include <stdint.h> +#include <string> + +#include "libcamera/internal/v4l2_pixelformat.h" + +namespace libcamera { + +enum class Transform; + +class ColorFilterArray +{ +public: + enum Order : uint8_t { + BGGR = 0, + GBRG = 1, + GRBG = 2, + RGGB = 3, + MONO = 4 + }; + + constexpr ColorFilterArray() : order(Order::BGGR) + { + } + + constexpr ColorFilterArray(Order o) + : order(o) + { + } + + static std::optional<ColorFilterArray> fromMbusCode(unsigned int mbusCode); + static std::optional<ColorFilterArray> fromV4L2PixelFormat(V4L2PixelFormat v4l2Format); + unsigned int toMbusCode(uint8_t bitDepth) const; + + std::string toString() const; + + bool operator==(const ColorFilterArray &other) const { + return this->order == other.order; + } + + ColorFilterArray transform(Transform t) const; + + Order order; +}; + +std::ostream &operator<<(std::ostream &out, const ColorFilterArray &f); + +} /* namespace libcamera */ diff --git a/include/libcamera/internal/bayer_format.h b/include/libcamera/internal/bayer_format.h index 5c14bb5fb2d5..701e063edcc5 100644 --- a/include/libcamera/internal/bayer_format.h +++ b/include/libcamera/internal/bayer_format.h @@ -11,6 +11,7 @@ #include <stdint.h> #include <string> +#include <libcamera/color_filter_array.h> #include <libcamera/pixel_format.h> #include "libcamera/internal/v4l2_pixelformat.h" @@ -22,14 +23,6 @@ enum class Transform; class BayerFormat { public: - enum Order : uint8_t { - BGGR = 0, - GBRG = 1, - GRBG = 2, - RGGB = 3, - MONO = 4 - }; - enum class Packing : uint16_t { None = 0, CSI2 = 1, @@ -39,12 +32,12 @@ public: }; constexpr BayerFormat() - : order(Order::BGGR), bitDepth(0), packing(Packing::None) + : cfa(ColorFilterArray()), bitDepth(0), packing(Packing::None) { } - constexpr BayerFormat(Order o, uint8_t b, Packing p) - : order(o), bitDepth(b), packing(p) + constexpr BayerFormat(ColorFilterArray c, uint8_t b, Packing p) + : cfa(c), bitDepth(b), packing(p) { } @@ -57,9 +50,8 @@ public: static BayerFormat fromV4L2PixelFormat(V4L2PixelFormat v4l2Format); PixelFormat toPixelFormat() const; static BayerFormat fromPixelFormat(PixelFormat format); - BayerFormat transform(Transform t) const; - Order order; + ColorFilterArray cfa; uint8_t bitDepth; Packing packing; diff --git a/include/libcamera/internal/camera_sensor.h b/include/libcamera/internal/camera_sensor.h index 2a2f1f2c936d..a0f27ac11735 100644 --- a/include/libcamera/internal/camera_sensor.h +++ b/include/libcamera/internal/camera_sensor.h @@ -16,13 +16,13 @@ #include <libcamera/base/class.h> +#include <libcamera/color_filter_array.h> #include <libcamera/control_ids.h> #include <libcamera/controls.h> #include <libcamera/geometry.h> #include <libcamera/orientation.h> #include <libcamera/transform.h> -#include "libcamera/internal/bayer_format.h" #include "libcamera/internal/camera_sensor_properties.h" #include "libcamera/internal/v4l2_subdevice.h" @@ -72,7 +72,7 @@ public: virtual const ControlList &properties() const = 0; virtual int sensorInfo(IPACameraSensorInfo *info) const = 0; virtual Transform computeTransform(Orientation *orientation) const = 0; - virtual BayerFormat::Order bayerOrder(Transform t) const = 0; + virtual ColorFilterArray bayerOrder(Transform t) const = 0; virtual Orientation mountingOrientation() const = 0; virtual const ControlInfoMap &controls() const = 0; diff --git a/include/libcamera/internal/software_isp/swstats_cpu.h b/include/libcamera/internal/software_isp/swstats_cpu.h index 551870921862..1594e520c5ba 100644 --- a/include/libcamera/internal/software_isp/swstats_cpu.h +++ b/include/libcamera/internal/software_isp/swstats_cpu.h @@ -88,7 +88,7 @@ private: using statsProcessFn = void (SwStatsCpu::*)(const uint8_t *src[], SwIspStats &stats); using processFrameFn = void (SwStatsCpu::*)(MappedFrameBuffer &in); - int setupStandardBayerOrder(BayerFormat::Order order); + int setupStandardBayerOrder(ColorFilterArray::Order order); /* Bayer 8 bpp unpacked */ void statsBGGR8Line0(const uint8_t *src[], SwIspStats &stats); /* Bayer 10 bpp unpacked */ diff --git a/include/libcamera/meson.build b/include/libcamera/meson.build index 30ea76f9470a..70bd0ccbed9e 100644 --- a/include/libcamera/meson.build +++ b/include/libcamera/meson.build @@ -5,6 +5,7 @@ libcamera_include_dir = 'libcamera' / 'libcamera' libcamera_public_headers = files([ 'camera.h', 'camera_manager.h', + 'color_filter_array.h', 'color_space.h', 'controls.h', 'fence.h', diff --git a/src/ipa/mali-c55/algorithms/agc.cpp b/src/ipa/mali-c55/algorithms/agc.cpp index 2c747da89170..8600e7d61922 100644 --- a/src/ipa/mali-c55/algorithms/agc.cpp +++ b/src/ipa/mali-c55/algorithms/agc.cpp @@ -54,28 +54,28 @@ uint32_t AgcStatistics::decodeBinValue(uint16_t binVal) * colour channels would be populated, and they may not be in the same * planes as calculated here. */ -int AgcStatistics::setBayerOrderIndices(BayerFormat::Order bayerOrder) +int AgcStatistics::setBayerOrderIndices(ColorFilterArray::Order cfaOrder) { - switch (bayerOrder) { - case BayerFormat::Order::RGGB: + switch (cfaOrder) { + case ColorFilterArray::Order::RGGB: rIndex_ = 0; grIndex_ = 1; gbIndex_ = 2; bIndex_ = 3; break; - case BayerFormat::Order::GRBG: + case ColorFilterArray::Order::GRBG: grIndex_ = 0; rIndex_ = 1; bIndex_ = 2; gbIndex_ = 3; break; - case BayerFormat::Order::GBRG: + case ColorFilterArray::Order::GBRG: gbIndex_ = 0; bIndex_ = 1; rIndex_ = 2; grIndex_ = 3; break; - case BayerFormat::Order::BGGR: + case ColorFilterArray::Order::BGGR: bIndex_ = 0; gbIndex_ = 1; grIndex_ = 2; @@ -83,7 +83,7 @@ int AgcStatistics::setBayerOrderIndices(BayerFormat::Order bayerOrder) break; default: LOG(MaliC55Agc, Error) - << "Invalid bayer format " << bayerOrder; + << "Invalid bayer format " << cfaOrder; return -EINVAL; } diff --git a/src/ipa/mali-c55/algorithms/agc.h b/src/ipa/mali-c55/algorithms/agc.h index 809a57c53acc..26c8dc78bc4b 100644 --- a/src/ipa/mali-c55/algorithms/agc.h +++ b/src/ipa/mali-c55/algorithms/agc.h @@ -8,8 +8,7 @@ #pragma once #include <libcamera/base/utils.h> - -#include "libcamera/internal/bayer_format.h" +#include <libcamera/color_filter_array.h> #include "libipa/agc.h" #include "libipa/histogram.h" @@ -28,7 +27,7 @@ public: { } - int setBayerOrderIndices(BayerFormat::Order bayerOrder); + int setBayerOrderIndices(ColorFilterArray::Order cfaOrder); uint32_t decodeBinValue(uint16_t binVal); void parseStatistics(const mali_c55_stats_buffer *stats); diff --git a/src/ipa/mali-c55/ipa_context.h b/src/ipa/mali-c55/ipa_context.h index cd370e25fcca..8915a8b82d57 100644 --- a/src/ipa/mali-c55/ipa_context.h +++ b/src/ipa/mali-c55/ipa_context.h @@ -8,12 +8,11 @@ #pragma once #include <libcamera/base/utils.h> +#include <libcamera/color_filter_array.h> #include <libcamera/controls.h> #include <libcamera/ipa/core_ipa_interface.h> -#include "libcamera/internal/bayer_format.h" - #include <libipa/agc.h> #include <libipa/camera_sensor_helper.h> #include <libipa/fc_queue.h> @@ -31,7 +30,7 @@ struct IPASessionConfiguration { agc::Session agc; struct { - BayerFormat::Order bayerOrder; + ColorFilterArray::Order bayerOrder; uint32_t blackLevel; } sensor; }; diff --git a/src/ipa/mali-c55/mali-c55.cpp b/src/ipa/mali-c55/mali-c55.cpp index 9a2918cf2cf1..d07c6666f7c5 100644 --- a/src/ipa/mali-c55/mali-c55.cpp +++ b/src/ipa/mali-c55/mali-c55.cpp @@ -17,11 +17,11 @@ #include <libcamera/base/log.h> #include <libcamera/control_ids.h> +#include <libcamera/color_filter_array.h> #include <libcamera/ipa/ipa_interface.h> #include <libcamera/ipa/ipa_module_info.h> #include <libcamera/ipa/mali-c55_ipa_interface.h> -#include "libcamera/internal/bayer_format.h" #include "libcamera/internal/mapped_framebuffer.h" #include "libcamera/internal/yaml_parser.h" @@ -171,7 +171,7 @@ int IPAMaliC55::configure(const IPAConfigInfo &ipaConfig, uint8_t bayerOrder, const IPACameraSensorInfo &info = ipaConfig.sensorInfo; - context_.configuration.sensor.bayerOrder = static_cast<BayerFormat::Order>(bayerOrder); + context_.configuration.sensor.bayerOrder = static_cast<ColorFilterArray::Order>(bayerOrder); if (auto bl = context_.camHelper->blackLevel()) { /* diff --git a/src/libcamera/bayer_format.cpp b/src/libcamera/bayer_format.cpp index 3dab91fc5f4b..c0d5af33dd17 100644 --- a/src/libcamera/bayer_format.cpp +++ b/src/libcamera/bayer_format.cpp @@ -14,6 +14,7 @@ #include <linux/media-bus-format.h> +#include <libcamera/color_filter_array.h> #include <libcamera/formats.h> #include <libcamera/transform.h> @@ -29,26 +30,8 @@ namespace libcamera { * \brief Class to represent a raw image Bayer format * * This class encodes the different Bayer formats in such a way that they can - * be easily manipulated. For example, the bit depth or Bayer order can be - * easily altered - the Bayer order can even be "transformed" in the same - * manner as happens in many sensors when their horizontal or vertical "flip" - * controls are set. - */ - -/** - * \enum BayerFormat::Order - * \brief The order of the colour channels in the Bayer pattern - * - * \var BayerFormat::BGGR - * \brief B then G on the first row, G then R on the second row. - * \var BayerFormat::GBRG - * \brief G then B on the first row, R then G on the second row. - * \var BayerFormat::GRBG - * \brief G then R on the first row, B then G on the second row. - * \var BayerFormat::RGGB - * \brief R then G on the first row, G then B on the second row. - * \var BayerFormat::MONO - * \brief Monochrome image data, there is no colour filter array. + * be easily manipulated. For example the bit depth, packing and color order of + * the format transmitted over the bus can be modified and transformed. */ /** @@ -78,9 +61,9 @@ struct BayerFormatComparator { else if (lhs.bitDepth > rhs.bitDepth) return false; - if (lhs.order < rhs.order) + if (lhs.cfa.order < rhs.cfa.order) return true; - else if (lhs.order > rhs.order) + else if (lhs.cfa.order > rhs.cfa.order) return false; if (lhs.packing < rhs.packing) @@ -96,143 +79,143 @@ struct Formats { }; const std::map<BayerFormat, Formats, BayerFormatComparator> bayerToFormat{ - { { BayerFormat::BGGR, 8, BayerFormat::Packing::None }, + { { ColorFilterArray::BGGR, 8, BayerFormat::Packing::None }, { formats::SBGGR8, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR8) } }, - { { BayerFormat::GBRG, 8, BayerFormat::Packing::None }, + { { ColorFilterArray::GBRG, 8, BayerFormat::Packing::None }, { formats::SGBRG8, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG8) } }, - { { BayerFormat::GRBG, 8, BayerFormat::Packing::None }, + { { ColorFilterArray::GRBG, 8, BayerFormat::Packing::None }, { formats::SGRBG8, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG8) } }, - { { BayerFormat::RGGB, 8, BayerFormat::Packing::None }, + { { ColorFilterArray::RGGB, 8, BayerFormat::Packing::None }, { formats::SRGGB8, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB8) } }, - { { BayerFormat::BGGR, 10, BayerFormat::Packing::None }, + { { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None }, { formats::SBGGR10, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR10) } }, - { { BayerFormat::GBRG, 10, BayerFormat::Packing::None }, + { { ColorFilterArray::GBRG, 10, BayerFormat::Packing::None }, { formats::SGBRG10, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG10) } }, - { { BayerFormat::GRBG, 10, BayerFormat::Packing::None }, + { { ColorFilterArray::GRBG, 10, BayerFormat::Packing::None }, { formats::SGRBG10, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG10) } }, - { { BayerFormat::RGGB, 10, BayerFormat::Packing::None }, + { { ColorFilterArray::RGGB, 10, BayerFormat::Packing::None }, { formats::SRGGB10, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB10) } }, - { { BayerFormat::BGGR, 10, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::BGGR, 10, BayerFormat::Packing::CSI2 }, { formats::SBGGR10_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR10P) } }, - { { BayerFormat::GBRG, 10, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GBRG, 10, BayerFormat::Packing::CSI2 }, { formats::SGBRG10_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG10P) } }, - { { BayerFormat::GRBG, 10, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GRBG, 10, BayerFormat::Packing::CSI2 }, { formats::SGRBG10_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG10P) } }, - { { BayerFormat::RGGB, 10, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::RGGB, 10, BayerFormat::Packing::CSI2 }, { formats::SRGGB10_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB10P) } }, - { { BayerFormat::BGGR, 10, BayerFormat::Packing::IPU3 }, + { { ColorFilterArray::BGGR, 10, BayerFormat::Packing::IPU3 }, { formats::SBGGR10_IPU3, V4L2PixelFormat(V4L2_PIX_FMT_IPU3_SBGGR10) } }, - { { BayerFormat::GBRG, 10, BayerFormat::Packing::IPU3 }, + { { ColorFilterArray::GBRG, 10, BayerFormat::Packing::IPU3 }, { formats::SGBRG10_IPU3, V4L2PixelFormat(V4L2_PIX_FMT_IPU3_SGBRG10) } }, - { { BayerFormat::GRBG, 10, BayerFormat::Packing::IPU3 }, + { { ColorFilterArray::GRBG, 10, BayerFormat::Packing::IPU3 }, { formats::SGRBG10_IPU3, V4L2PixelFormat(V4L2_PIX_FMT_IPU3_SGRBG10) } }, - { { BayerFormat::RGGB, 10, BayerFormat::Packing::IPU3 }, + { { ColorFilterArray::RGGB, 10, BayerFormat::Packing::IPU3 }, { formats::SRGGB10_IPU3, V4L2PixelFormat(V4L2_PIX_FMT_IPU3_SRGGB10) } }, - { { BayerFormat::BGGR, 12, BayerFormat::Packing::None }, + { { ColorFilterArray::BGGR, 12, BayerFormat::Packing::None }, { formats::SBGGR12, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR12) } }, - { { BayerFormat::GBRG, 12, BayerFormat::Packing::None }, + { { ColorFilterArray::GBRG, 12, BayerFormat::Packing::None }, { formats::SGBRG12, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG12) } }, - { { BayerFormat::GRBG, 12, BayerFormat::Packing::None }, + { { ColorFilterArray::GRBG, 12, BayerFormat::Packing::None }, { formats::SGRBG12, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG12) } }, - { { BayerFormat::RGGB, 12, BayerFormat::Packing::None }, + { { ColorFilterArray::RGGB, 12, BayerFormat::Packing::None }, { formats::SRGGB12, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB12) } }, - { { BayerFormat::BGGR, 12, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::BGGR, 12, BayerFormat::Packing::CSI2 }, { formats::SBGGR12_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR12P) } }, - { { BayerFormat::GBRG, 12, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GBRG, 12, BayerFormat::Packing::CSI2 }, { formats::SGBRG12_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG12P) } }, - { { BayerFormat::GRBG, 12, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GRBG, 12, BayerFormat::Packing::CSI2 }, { formats::SGRBG12_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG12P) } }, - { { BayerFormat::RGGB, 12, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::RGGB, 12, BayerFormat::Packing::CSI2 }, { formats::SRGGB12_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB12P) } }, - { { BayerFormat::BGGR, 14, BayerFormat::Packing::None }, + { { ColorFilterArray::BGGR, 14, BayerFormat::Packing::None }, { formats::SBGGR14, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR14) } }, - { { BayerFormat::GBRG, 14, BayerFormat::Packing::None }, + { { ColorFilterArray::GBRG, 14, BayerFormat::Packing::None }, { formats::SGBRG14, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG14) } }, - { { BayerFormat::GRBG, 14, BayerFormat::Packing::None }, + { { ColorFilterArray::GRBG, 14, BayerFormat::Packing::None }, { formats::SGRBG14, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG14) } }, - { { BayerFormat::RGGB, 14, BayerFormat::Packing::None }, + { { ColorFilterArray::RGGB, 14, BayerFormat::Packing::None }, { formats::SRGGB14, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB14) } }, - { { BayerFormat::BGGR, 14, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::BGGR, 14, BayerFormat::Packing::CSI2 }, { formats::SBGGR14_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR14P) } }, - { { BayerFormat::GBRG, 14, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GBRG, 14, BayerFormat::Packing::CSI2 }, { formats::SGBRG14_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG14P) } }, - { { BayerFormat::GRBG, 14, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::GRBG, 14, BayerFormat::Packing::CSI2 }, { formats::SGRBG14_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG14P) } }, - { { BayerFormat::RGGB, 14, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::RGGB, 14, BayerFormat::Packing::CSI2 }, { formats::SRGGB14_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB14P) } }, - { { BayerFormat::BGGR, 16, BayerFormat::Packing::None }, + { { ColorFilterArray::BGGR, 16, BayerFormat::Packing::None }, { formats::SBGGR16, V4L2PixelFormat(V4L2_PIX_FMT_SBGGR16) } }, - { { BayerFormat::GBRG, 16, BayerFormat::Packing::None }, + { { ColorFilterArray::GBRG, 16, BayerFormat::Packing::None }, { formats::SGBRG16, V4L2PixelFormat(V4L2_PIX_FMT_SGBRG16) } }, - { { BayerFormat::GRBG, 16, BayerFormat::Packing::None }, + { { ColorFilterArray::GRBG, 16, BayerFormat::Packing::None }, { formats::SGRBG16, V4L2PixelFormat(V4L2_PIX_FMT_SGRBG16) } }, - { { BayerFormat::RGGB, 16, BayerFormat::Packing::None }, + { { ColorFilterArray::RGGB, 16, BayerFormat::Packing::None }, { formats::SRGGB16, V4L2PixelFormat(V4L2_PIX_FMT_SRGGB16) } }, - { { BayerFormat::BGGR, 16, BayerFormat::Packing::PISP1 }, + { { ColorFilterArray::BGGR, 16, BayerFormat::Packing::PISP1 }, { formats::BGGR_PISP_COMP1, V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_BGGR) } }, - { { BayerFormat::GBRG, 16, BayerFormat::Packing::PISP1 }, + { { ColorFilterArray::GBRG, 16, BayerFormat::Packing::PISP1 }, { formats::GBRG_PISP_COMP1, V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_GBRG) } }, - { { BayerFormat::GRBG, 16, BayerFormat::Packing::PISP1 }, + { { ColorFilterArray::GRBG, 16, BayerFormat::Packing::PISP1 }, { formats::GRBG_PISP_COMP1, V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_GRBG) } }, - { { BayerFormat::RGGB, 16, BayerFormat::Packing::PISP1 }, + { { ColorFilterArray::RGGB, 16, BayerFormat::Packing::PISP1 }, { formats::RGGB_PISP_COMP1, V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_RGGB) } }, - { { BayerFormat::MONO, 8, BayerFormat::Packing::None }, + { { ColorFilterArray::MONO, 8, BayerFormat::Packing::None }, { formats::R8, V4L2PixelFormat(V4L2_PIX_FMT_GREY) } }, - { { BayerFormat::MONO, 10, BayerFormat::Packing::None }, + { { ColorFilterArray::MONO, 10, BayerFormat::Packing::None }, { formats::R10, V4L2PixelFormat(V4L2_PIX_FMT_Y10) } }, - { { BayerFormat::MONO, 10, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::MONO, 10, BayerFormat::Packing::CSI2 }, { formats::R10_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_Y10P) } }, - { { BayerFormat::MONO, 12, BayerFormat::Packing::None }, + { { ColorFilterArray::MONO, 12, BayerFormat::Packing::None }, { formats::R12, V4L2PixelFormat(V4L2_PIX_FMT_Y12) } }, - { { BayerFormat::MONO, 12, BayerFormat::Packing::CSI2 }, + { { ColorFilterArray::MONO, 12, BayerFormat::Packing::CSI2 }, { formats::R12_CSI2P, V4L2PixelFormat(V4L2_PIX_FMT_Y12P) } }, - { { BayerFormat::MONO, 16, BayerFormat::Packing::None }, + { { ColorFilterArray::MONO, 16, BayerFormat::Packing::None }, { formats::R16, V4L2PixelFormat(V4L2_PIX_FMT_Y16) } }, - { { BayerFormat::MONO, 16, BayerFormat::Packing::PISP1 }, + { { ColorFilterArray::MONO, 16, BayerFormat::Packing::PISP1 }, { formats::MONO_PISP_COMP1, V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_MONO) } }, }; const std::unordered_map<unsigned int, BayerFormat> mbusCodeToBayer{ - { MEDIA_BUS_FMT_SBGGR8_1X8, { BayerFormat::BGGR, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG8_1X8, { BayerFormat::GBRG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG8_1X8, { BayerFormat::GRBG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB8_1X8, { BayerFormat::RGGB, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, { BayerFormat::BGGR, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8, { BayerFormat::GBRG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, { BayerFormat::GRBG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8, { BayerFormat::RGGB, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, { BayerFormat::BGGR, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, { BayerFormat::GBRG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, { BayerFormat::GRBG, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, { BayerFormat::RGGB, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE, { BayerFormat::BGGR, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, { BayerFormat::BGGR, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE, { BayerFormat::BGGR, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE, { BayerFormat::BGGR, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR10_1X10, { BayerFormat::BGGR, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG10_1X10, { BayerFormat::GBRG, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG10_1X10, { BayerFormat::GRBG, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB10_1X10, { BayerFormat::RGGB, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR12_1X12, { BayerFormat::BGGR, 12, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG12_1X12, { BayerFormat::GBRG, 12, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG12_1X12, { BayerFormat::GRBG, 12, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB12_1X12, { BayerFormat::RGGB, 12, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR14_1X14, { BayerFormat::BGGR, 14, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG14_1X14, { BayerFormat::GBRG, 14, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG14_1X14, { BayerFormat::GRBG, 14, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB14_1X14, { BayerFormat::RGGB, 14, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR16_1X16, { BayerFormat::BGGR, 16, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG16_1X16, { BayerFormat::GBRG, 16, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG16_1X16, { BayerFormat::GRBG, 16, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB16_1X16, { BayerFormat::RGGB, 16, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SBGGR20_1X20, { BayerFormat::BGGR, 20, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGBRG20_1X20, { BayerFormat::GBRG, 20, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SGRBG20_1X20, { BayerFormat::GRBG, 20, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_SRGGB20_1X20, { BayerFormat::RGGB, 20, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_Y8_1X8, { BayerFormat::MONO, 8, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_Y10_1X10, { BayerFormat::MONO, 10, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_Y12_1X12, { BayerFormat::MONO, 12, BayerFormat::Packing::None } }, - { MEDIA_BUS_FMT_Y16_1X16, { BayerFormat::MONO, 16, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR8_1X8, { ColorFilterArray::BGGR, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG8_1X8, { ColorFilterArray::GBRG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG8_1X8, { ColorFilterArray::GRBG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB8_1X8, { ColorFilterArray::RGGB, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, { ColorFilterArray::BGGR, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8, { ColorFilterArray::GBRG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, { ColorFilterArray::GRBG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8, { ColorFilterArray::RGGB, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, { ColorFilterArray::BGGR, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, { ColorFilterArray::GBRG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, { ColorFilterArray::GRBG, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, { ColorFilterArray::RGGB, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE, { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE, { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE, { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR10_1X10, { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG10_1X10, { ColorFilterArray::GBRG, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG10_1X10, { ColorFilterArray::GRBG, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB10_1X10, { ColorFilterArray::RGGB, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR12_1X12, { ColorFilterArray::BGGR, 12, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG12_1X12, { ColorFilterArray::GBRG, 12, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG12_1X12, { ColorFilterArray::GRBG, 12, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB12_1X12, { ColorFilterArray::RGGB, 12, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR14_1X14, { ColorFilterArray::BGGR, 14, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG14_1X14, { ColorFilterArray::GBRG, 14, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG14_1X14, { ColorFilterArray::GRBG, 14, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB14_1X14, { ColorFilterArray::RGGB, 14, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR16_1X16, { ColorFilterArray::BGGR, 16, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG16_1X16, { ColorFilterArray::GBRG, 16, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG16_1X16, { ColorFilterArray::GRBG, 16, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB16_1X16, { ColorFilterArray::RGGB, 16, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SBGGR20_1X20, { ColorFilterArray::BGGR, 20, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGBRG20_1X20, { ColorFilterArray::GBRG, 20, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SGRBG20_1X20, { ColorFilterArray::GRBG, 20, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_SRGGB20_1X20, { ColorFilterArray::RGGB, 20, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_Y8_1X8, { ColorFilterArray::MONO, 8, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_Y10_1X10, { ColorFilterArray::MONO, 10, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_Y12_1X12, { ColorFilterArray::MONO, 12, BayerFormat::Packing::None } }, + { MEDIA_BUS_FMT_Y16_1X16, { ColorFilterArray::MONO, 16, BayerFormat::Packing::None } }, }; } /* namespace */ @@ -243,9 +226,9 @@ const std::unordered_map<unsigned int, BayerFormat> mbusCodeToBayer{ */ /** - * \fn BayerFormat::BayerFormat(Order o, uint8_t b, Packing p) + * \fn BayerFormat::BayerFormat(ColorFilterArray c, uint8_t b, Packing p) * \brief Construct a BayerFormat from explicit values - * \param[in] o The order of the Bayer pattern + * \param[in] c The color filter array pattern * \param[in] b The bit depth of the Bayer samples * \param[in] p The type of packing applied to the pixel values */ @@ -291,7 +274,7 @@ std::string BayerFormat::toString() const */ bool operator==(const BayerFormat &lhs, const BayerFormat &rhs) { - return lhs.order == rhs.order && lhs.bitDepth == rhs.bitDepth && + return lhs.cfa.order == rhs.cfa.order && lhs.bitDepth == rhs.bitDepth && lhs.packing == rhs.packing; } @@ -303,21 +286,13 @@ bool operator==(const BayerFormat &lhs, const BayerFormat &rhs) */ std::ostream &operator<<(std::ostream &out, const BayerFormat &f) { - static const char *orderStrings[] = { - "BGGR-", - "GBRG-", - "GRBG-", - "RGGB-", - "MONO-" - }; - - if (!f.isValid() || f.order > BayerFormat::MONO) { + if (!f.isValid() || f.cfa.order > ColorFilterArray::MONO) { out << "INVALID"; return out; } /* The cast is required to avoid bitDepth being interpreted as a char. */ - out << orderStrings[f.order] << static_cast<unsigned int>(f.bitDepth); + out << f.cfa << "-" << static_cast<unsigned int>(f.bitDepth); if (f.packing == BayerFormat::Packing::CSI2) out << "-CSI2P"; @@ -398,53 +373,8 @@ BayerFormat BayerFormat::fromPixelFormat(PixelFormat format) } /** - * \brief Apply a transform to this BayerFormat - * \param[in] t The transform to apply - * - * Applying a transform to an image stored in a Bayer format affects the Bayer - * order. For example, performing a horizontal flip on the Bayer pattern RGGB - * causes the RG rows of pixels to become GR, and the GB rows to become BG. The - * transformed image would have a GRBG order. Performing a vertical flip on the - * Bayer pattern RGGB causes the GB rows to come before the RG ones and the - * transformed image would have GBRG order. Applying both vertical and - * horizontal flips on the Bayer patter RGGB results in transformed images with - * BGGR order. The bit depth and modifiers are not affected. - * - * Horizontal and vertical flips are applied before transpose. - * - * \return The transformed Bayer format - */ -BayerFormat BayerFormat::transform(Transform t) const -{ - BayerFormat result = *this; - - if (order == MONO) - return result; - - /* - * Observe that flipping bit 0 of the Order enum performs a horizontal - * mirror on the Bayer pattern (e.g. RG/GB goes to GR/BG). Similarly, - * flipping bit 1 performs a vertical mirror operation on it (e.g RG/GB - * goes to GB/RG). Applying both vertical and horizontal flips - * combines vertical and horizontal mirroring on the Bayer pattern - * (e.g. RG/GB goes to BG/GR). Hence: - */ - if (!!(t & Transform::HFlip)) - result.order = static_cast<Order>(result.order ^ 1); - if (!!(t & Transform::VFlip)) - result.order = static_cast<Order>(result.order ^ 2); - - if (!!(t & Transform::Transpose) && result.order == 1) - result.order = static_cast<Order>(2); - else if (!!(t & Transform::Transpose) && result.order == 2) - result.order = static_cast<Order>(1); - - return result; -} - -/** - * \var BayerFormat::order - * \brief The order of the colour channels in the Bayer pattern + * \var BayerFormat::cfa + * \brief The color filter array pattern */ /** diff --git a/src/libcamera/color_filter_array.cpp b/src/libcamera/color_filter_array.cpp new file mode 100644 index 000000000000..7cec14d2dce4 --- /dev/null +++ b/src/libcamera/color_filter_array.cpp @@ -0,0 +1,334 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, Ideas on Board Oy + * + * Class to represent Bayer Color Filter Array patterns + */ + +#include <libcamera/color_filter_array.h> + +#include <optional> +#include <map> +#include <sstream> +#include <unordered_map> + +#include <linux/media-bus-format.h> + +#include <libcamera/transform.h> +#include "libcamera/internal/v4l2_pixelformat.h" + +/** + * \file color_filter_array.cpp + * \brief Class to represent and manipulate patterns of the color filter array + */ + +namespace libcamera { + +/** + * \class ColorFilterArray + * \brief Class to represent a color filter array + * + * This class encodes the different patterns of the color filter array in such + * a way that they can be easily manipulated. For example the order can be + * "transformed" in the same manner as happens in many sensors when their + * horizontal or vertical "flip" controls are set. + */ + +/** + * \enum ColorFilterArray::Order + * \brief Different ordering of color channels in a filter array + * + * \var ColorFilterArray::BGGR + * \brief B then G on the first row, G then R on the second row. + * \var ColorFilterArray::GBRG + * \brief G then B on the first row, R then G on the second row. + * \var ColorFilterArray::GRBG + * \brief G then R on the first row, B then G on the second row. + * \var ColorFilterArray::RGGB + * \brief R then G on the first row, G then B on the second row. + * \var ColorFilterArray::MONO + * \brief Monochrome image data, there is no color filter array. + */ + +namespace { + +const std::unordered_map<unsigned int, ColorFilterArray> mbusCodeToCFA { + { MEDIA_BUS_FMT_SBGGR8_1X8, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG8_1X8, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG8_1X8, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB8_1X8, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SBGGR10_1X10, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG10_1X10, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG10_1X10, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB10_1X10, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR12_1X12, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG12_1X12, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG12_1X12, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB12_1X12, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR14_1X14, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG14_1X14, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG14_1X14, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB14_1X14, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR16_1X16, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG16_1X16, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG16_1X16, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB16_1X16, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_SBGGR20_1X20, ColorFilterArray::BGGR }, + { MEDIA_BUS_FMT_SGBRG20_1X20, ColorFilterArray::GBRG }, + { MEDIA_BUS_FMT_SGRBG20_1X20, ColorFilterArray::GRBG }, + { MEDIA_BUS_FMT_SRGGB20_1X20, ColorFilterArray::RGGB }, + { MEDIA_BUS_FMT_Y8_1X8, ColorFilterArray::MONO }, + { MEDIA_BUS_FMT_Y10_1X10, ColorFilterArray::MONO }, + { MEDIA_BUS_FMT_Y12_1X12, ColorFilterArray::MONO }, + { MEDIA_BUS_FMT_Y16_1X16, ColorFilterArray::MONO }, +}; + +struct CfaMbusEntry { + ColorFilterArray cfa; + uint8_t bitDepth; + + bool operator<(const CfaMbusEntry& o) const { + return std::tie(cfa.order, bitDepth) < std::tie(o.cfa.order, o.bitDepth); + } +}; + +const std::map<CfaMbusEntry, unsigned int> cfaBitDepthToMbusCode{ + { { ColorFilterArray::BGGR, 8 }, MEDIA_BUS_FMT_SBGGR8_1X8 }, + { { ColorFilterArray::BGGR, 10 }, MEDIA_BUS_FMT_SBGGR10_1X10 }, + { { ColorFilterArray::BGGR, 12 }, MEDIA_BUS_FMT_SBGGR12_1X12 }, + { { ColorFilterArray::BGGR, 14 }, MEDIA_BUS_FMT_SBGGR14_1X14 }, + { { ColorFilterArray::BGGR, 16 }, MEDIA_BUS_FMT_SBGGR16_1X16 }, + { { ColorFilterArray::BGGR, 20 }, MEDIA_BUS_FMT_SBGGR20_1X20 }, + { { ColorFilterArray::GBRG, 8 }, MEDIA_BUS_FMT_SGBRG8_1X8 }, + { { ColorFilterArray::GBRG, 10 }, MEDIA_BUS_FMT_SGBRG10_1X10 }, + { { ColorFilterArray::GBRG, 12 }, MEDIA_BUS_FMT_SGBRG12_1X12 }, + { { ColorFilterArray::GBRG, 14 }, MEDIA_BUS_FMT_SGBRG14_1X14 }, + { { ColorFilterArray::GBRG, 16 }, MEDIA_BUS_FMT_SGBRG16_1X16 }, + { { ColorFilterArray::GBRG, 20 }, MEDIA_BUS_FMT_SGBRG20_1X20 }, + { { ColorFilterArray::GRBG, 8 }, MEDIA_BUS_FMT_SGRBG8_1X8 }, + { { ColorFilterArray::GRBG, 10 }, MEDIA_BUS_FMT_SGRBG10_1X10 }, + { { ColorFilterArray::GRBG, 12 }, MEDIA_BUS_FMT_SGRBG12_1X12 }, + { { ColorFilterArray::GRBG, 14 }, MEDIA_BUS_FMT_SGRBG14_1X14 }, + { { ColorFilterArray::GRBG, 16 }, MEDIA_BUS_FMT_SGRBG16_1X16 }, + { { ColorFilterArray::GRBG, 20 }, MEDIA_BUS_FMT_SGRBG20_1X20 }, + { { ColorFilterArray::RGGB, 8 }, MEDIA_BUS_FMT_SRGGB8_1X8 }, + { { ColorFilterArray::RGGB, 10 }, MEDIA_BUS_FMT_SRGGB10_1X10 }, + { { ColorFilterArray::RGGB, 12 }, MEDIA_BUS_FMT_SRGGB12_1X12 }, + { { ColorFilterArray::RGGB, 14 }, MEDIA_BUS_FMT_SRGGB14_1X14 }, + { { ColorFilterArray::RGGB, 16 }, MEDIA_BUS_FMT_SRGGB16_1X16 }, + { { ColorFilterArray::RGGB, 20 }, MEDIA_BUS_FMT_SRGGB20_1X20 }, + { { ColorFilterArray::MONO, 8 }, MEDIA_BUS_FMT_Y8_1X8 }, + { { ColorFilterArray::MONO, 10 }, MEDIA_BUS_FMT_Y10_1X10 }, + { { ColorFilterArray::MONO, 12 }, MEDIA_BUS_FMT_Y12_1X12 }, + { { ColorFilterArray::MONO, 16 }, MEDIA_BUS_FMT_Y16_1X16 }, +}; + +const std::unordered_map<V4L2PixelFormat, ColorFilterArray> v4l2FormatToCFA { + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR8), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG8), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG8), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB8), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR10), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG10), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG10), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB10), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR10P), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG10P), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG10P), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB10P), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR12), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG12), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG12), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB12), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR12P), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG12P), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG12P), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB12P), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR14), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG14), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG14), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB14), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR14P), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG14P), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG14P), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB14P), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_SBGGR16), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGBRG16), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SGRBG16), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_SRGGB16), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_BGGR), ColorFilterArray::BGGR }, + { V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_GBRG), ColorFilterArray::GBRG }, + { V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_GRBG), ColorFilterArray::GRBG }, + { V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_RGGB), ColorFilterArray::RGGB }, + { V4L2PixelFormat(V4L2_PIX_FMT_PISP_COMP1_MONO), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_GREY), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_Y10), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_Y10P), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_Y12), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_Y12P), ColorFilterArray::MONO }, + { V4L2PixelFormat(V4L2_PIX_FMT_Y16), ColorFilterArray::MONO }, +}; + +} /* namespace */ + +/** + * \fn ColorFilterArray::ColorFilterArray() + * \brief Construct an empty (and invalid) ColorFilterArray + */ + +/** + * \fn ColorFilterArray::ColorFilterArray(Order o) + * \brief Construct a ColorFilterArray from an explicit order value + * \param[in] o The order of color channels in the filter array + */ + +/** + * \brief Retrieve the ColorFilterArray associated with a media bus code + * \param[in] mbusCode The media bus code to convert into a ColorFilterArray + * + * The media bus code numeric identifiers are defined by the V4L2 specification. + */ +std::optional<ColorFilterArray> ColorFilterArray::fromMbusCode(unsigned int mbusCode) +{ + const auto it = mbusCodeToCFA.find(mbusCode); + + if (it == mbusCodeToCFA.end()) + return std::nullopt; + else + return it->second; +} + +/** + * \brief Retrieve the ColorFilterArray associated with a V4L2PixelFormat + * \param[in] v4l2Format The raw format to convert into a ColorFilterArray + * + * The media bus code numeric identifiers are defined by the V4L2 specification. + */ +std::optional<ColorFilterArray> ColorFilterArray::fromV4L2PixelFormat(V4L2PixelFormat v4l2Format) +{ + const auto it = v4l2FormatToCFA.find(v4l2Format); + + if (it == v4l2FormatToCFA.end()) + return std::nullopt; + else + return it->second; +} + +/** + * \brief Retrieve the media bus code for this ColorFilterArray and bit depth + * \param[in] bitDepth The bit depth of the samples transmitted over the bus + * \return The media bus code, or 0 if no code exists for the combination + * + * The returned code is the order-specific sensor bus code (e.g. + * MEDIA_BUS_FMT_SBGGR10_1X10). + */ +unsigned int ColorFilterArray::toMbusCode(uint8_t bitDepth) const +{ + const auto it = cfaBitDepthToMbusCode.find({*this, bitDepth}); + + if (it == cfaBitDepthToMbusCode.end()) + return 0; + else + return it->second; +} + +/** + * \brief Assemble and return a readable string representation of the + * ColorFilterArray + * \return A string describing the ColorFilterArray + */ +std::string ColorFilterArray::toString() const +{ + std::stringstream ss; + ss << *this; + + return ss.str(); +} + +/** + * \brief Insert a text representation of a ColorFilterArrays into an output stream + * \param[in] out The output stream + * \param[in] f The ColorFilterArray + * \return The output stream \a out + */ +std::ostream &operator<<(std::ostream &out, const ColorFilterArray &f) +{ + switch (f.order) { + case ColorFilterArray::BGGR: + return out << "BGGR"; + case ColorFilterArray::GBRG: + return out << "GBRG"; + case ColorFilterArray::GRBG: + return out << "GRBG"; + case ColorFilterArray::RGGB: + return out << "RGGB"; + case ColorFilterArray::MONO: + return out << "MONO"; + default: + return out << "INVALID"; + } +} + +/** + * \brief Apply a transform to this ColorFilterArray + * \param[in] t The transform to apply + * + * Applying a transform to an image captured via a ColorFilterArray affects the + * color order. For example, performing a horizontal flip on the pattern 2x2 + * RGGB causes the RG rows of pixels to become GR, and the GB rows to become + * BG. The transformed image would have a GRBG order. Performing a vertical + * flip on the 2x2 pattern RGGB causes the GB rows to come before the RG ones + * and the transformed image would have GBRG order. Applying both vertical and + * horizontal flips on the 2x2 pattern RGGB results in transformed images with + * BGGR order. + * + * Horizontal and vertical flips are applied before transpose. + * + * \return The transformed pattern as a ColorFilterArray + */ +ColorFilterArray ColorFilterArray::transform(Transform t) const +{ + ColorFilterArray result = *this; + + if (order == MONO) + return result; + + /* + * Observe that flipping bit 0 of the Order enum performs a horizontal + * mirror on the Bayer pattern (e.g. RG/GB goes to GR/BG). Similarly, + * flipping bit 1 performs a vertical mirror operation on it (e.g RG/GB + * goes to GB/RG). Applying both vertical and horizontal flips + * combines vertical and horizontal mirroring on the Bayer pattern + * (e.g. RG/GB goes to BG/GR). Hence: + */ + if (!!(t & Transform::HFlip)) + result.order = static_cast<Order>(result.order ^ 1); + if (!!(t & Transform::VFlip)) + result.order = static_cast<Order>(result.order ^ 2); + + if (!!(t & Transform::Transpose) && result.order == 1) + result.order = static_cast<Order>(2); + else if (!!(t & Transform::Transpose) && result.order == 2) + result.order = static_cast<Order>(1); + + return result; +} + +/** + * \var ColorFilterArray::order + * \brief The order of the color channels in the filter array + */ + +} /* namespace libcamera */ diff --git a/src/libcamera/meson.build b/src/libcamera/meson.build index 17c1b2cb3479..056f30252eaf 100644 --- a/src/libcamera/meson.build +++ b/src/libcamera/meson.build @@ -22,6 +22,7 @@ libcamera_internal_sources = files([ 'camera_controls.cpp', 'camera_lens.cpp', 'clock_recovery.cpp', + 'color_filter_array.cpp', 'control_serializer.cpp', 'control_validator.cpp', 'converter.cpp', diff --git a/src/libcamera/pipeline/mali-c55/mali-c55.cpp b/src/libcamera/pipeline/mali-c55/mali-c55.cpp index 73a03373c833..af518d0b2c28 100644 --- a/src/libcamera/pipeline/mali-c55/mali-c55.cpp +++ b/src/libcamera/pipeline/mali-c55/mali-c55.cpp @@ -22,6 +22,7 @@ #include <libcamera/base/utils.h> #include <libcamera/camera.h> +#include <libcamera/color_filter_array.h> #include <libcamera/controls.h> #include <libcamera/formats.h> #include <libcamera/geometry.h> @@ -328,7 +329,7 @@ int MaliC55CameraData::pixfmtToMbusCode(const PixelFormat &pixFmt) const if (!sdBayerFormat.isValid()) continue; - if (sdBayerFormat.order != bayerFormat.order) + if (sdBayerFormat.cfa.order != bayerFormat.cfa.order) continue; if (sdBayerFormat.bitDepth > bitDepth) { @@ -368,7 +369,7 @@ const PixelFormat &MaliC55CameraData::bestRawFormat() const continue; BayerFormat bayer = BayerFormat::fromMbusCode(rawCode); - if (bayer.order == sensorBayer.order) + if (bayer.cfa.order == sensorBayer.cfa.order) return pixFmt; } } @@ -1175,14 +1176,14 @@ int PipelineHandlerMaliC55::configure(Camera *camera, ipaConfig.sensorControls = data->sensor()->controls(); /* - * And we also need to tell the IPA the bayerOrder of the data (as + * And we also need to tell the IPA the cfaOrder of the data (as * affected by any flips that we've configured) */ const Transform &combinedTransform = maliConfig->combinedTransform(); - BayerFormat::Order bayerOrder = data->sensor()->bayerOrder(combinedTransform); + ColorFilterArray::Order cfaOrder = data->sensor()->bayerOrder(combinedTransform); ControlInfoMap ipaControls; - ret = data->ipa_->configure(ipaConfig, utils::to_underlying(bayerOrder), + ret = data->ipa_->configure(ipaConfig, utils::to_underlying(cfaOrder), &ipaControls); if (ret) { LOG(MaliC55, Error) << "Failed to configure IPA"; diff --git a/src/libcamera/pipeline/rpi/common/pipeline_base.cpp b/src/libcamera/pipeline/rpi/common/pipeline_base.cpp index d6ce2dbf5cee..7ea48f62cc3d 100644 --- a/src/libcamera/pipeline/rpi/common/pipeline_base.cpp +++ b/src/libcamera/pipeline/rpi/common/pipeline_base.cpp @@ -16,6 +16,7 @@ #include <libcamera/base/file.h> #include <libcamera/base/utils.h> +#include <libcamera/color_filter_array.h> #include <libcamera/formats.h> #include <libcamera/logging.h> #include <libcamera/property_ids.h> @@ -75,7 +76,7 @@ bool isMonoSensor(std::unique_ptr<CameraSensor> &sensor) unsigned int mbusCode = sensor->mbusCodes()[0]; const BayerFormat &bayer = BayerFormat::fromMbusCode(mbusCode); - return bayer.order == BayerFormat::Order::MONO; + return bayer.cfa.order == ColorFilterArray::Order::MONO; } const std::vector<ColorSpace> validColorSpaces = { @@ -256,7 +257,7 @@ CameraConfiguration::Status RPiCameraConfiguration::validate() */ BayerFormat cfgBayer = BayerFormat::fromPixelFormat(rawStream->pixelFormat); - cfgBayer.order = data_->sensor_->bayerOrder(combinedTransform_); + cfgBayer.cfa = data_->sensor_->bayerOrder(combinedTransform_); if (rawStream->pixelFormat != cfgBayer.toPixelFormat()) { rawStream->pixelFormat = cfgBayer.toPixelFormat(); diff --git a/src/libcamera/pipeline/rpi/pisp/pisp.cpp b/src/libcamera/pipeline/rpi/pisp/pisp.cpp index d0103adbe17c..b4a5f87aa93d 100644 --- a/src/libcamera/pipeline/rpi/pisp/pisp.cpp +++ b/src/libcamera/pipeline/rpi/pisp/pisp.cpp @@ -56,32 +56,32 @@ constexpr unsigned int DefaultCompressionOffset = 2048; constexpr unsigned int DefaultCompressionMode = 1; const std::vector<std::pair<BayerFormat, unsigned int>> BayerToMbusCodeMap{ - { { BayerFormat::BGGR, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR8_1X8, }, - { { BayerFormat::GBRG, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG8_1X8, }, - { { BayerFormat::GRBG, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG8_1X8, }, - { { BayerFormat::RGGB, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB8_1X8, }, - { { BayerFormat::BGGR, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR10_1X10, }, - { { BayerFormat::GBRG, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG10_1X10, }, - { { BayerFormat::GRBG, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG10_1X10, }, - { { BayerFormat::RGGB, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB10_1X10, }, - { { BayerFormat::BGGR, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR12_1X12, }, - { { BayerFormat::GBRG, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG12_1X12, }, - { { BayerFormat::GRBG, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG12_1X12, }, - { { BayerFormat::RGGB, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB12_1X12, }, - { { BayerFormat::BGGR, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR14_1X14, }, - { { BayerFormat::GBRG, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG14_1X14, }, - { { BayerFormat::GRBG, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG14_1X14, }, - { { BayerFormat::RGGB, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB14_1X14, }, - { { BayerFormat::BGGR, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR16_1X16, }, - { { BayerFormat::GBRG, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG16_1X16, }, - { { BayerFormat::GRBG, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG16_1X16, }, - { { BayerFormat::RGGB, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB16_1X16, }, - { { BayerFormat::BGGR, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SBGGR16_1X16, }, - { { BayerFormat::GBRG, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SGBRG16_1X16, }, - { { BayerFormat::GRBG, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SGRBG16_1X16, }, - { { BayerFormat::RGGB, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SRGGB16_1X16, }, - { { BayerFormat::MONO, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_Y16_1X16, }, - { { BayerFormat::MONO, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_Y16_1X16, }, + { { ColorFilterArray::BGGR, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR8_1X8, }, + { { ColorFilterArray::GBRG, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG8_1X8, }, + { { ColorFilterArray::GRBG, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG8_1X8, }, + { { ColorFilterArray::RGGB, 8, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB8_1X8, }, + { { ColorFilterArray::BGGR, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR10_1X10, }, + { { ColorFilterArray::GBRG, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG10_1X10, }, + { { ColorFilterArray::GRBG, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG10_1X10, }, + { { ColorFilterArray::RGGB, 10, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB10_1X10, }, + { { ColorFilterArray::BGGR, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR12_1X12, }, + { { ColorFilterArray::GBRG, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG12_1X12, }, + { { ColorFilterArray::GRBG, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG12_1X12, }, + { { ColorFilterArray::RGGB, 12, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB12_1X12, }, + { { ColorFilterArray::BGGR, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR14_1X14, }, + { { ColorFilterArray::GBRG, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG14_1X14, }, + { { ColorFilterArray::GRBG, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG14_1X14, }, + { { ColorFilterArray::RGGB, 14, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB14_1X14, }, + { { ColorFilterArray::BGGR, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SBGGR16_1X16, }, + { { ColorFilterArray::GBRG, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGBRG16_1X16, }, + { { ColorFilterArray::GRBG, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SGRBG16_1X16, }, + { { ColorFilterArray::RGGB, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_SRGGB16_1X16, }, + { { ColorFilterArray::BGGR, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SBGGR16_1X16, }, + { { ColorFilterArray::GBRG, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SGBRG16_1X16, }, + { { ColorFilterArray::GRBG, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SGRBG16_1X16, }, + { { ColorFilterArray::RGGB, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_SRGGB16_1X16, }, + { { ColorFilterArray::MONO, 16, BayerFormat::Packing::None }, MEDIA_BUS_FMT_Y16_1X16, }, + { { ColorFilterArray::MONO, 16, BayerFormat::Packing::PISP1 }, MEDIA_BUS_FMT_Y16_1X16, }, }; unsigned int bayerToMbusCode(const BayerFormat &bayer) @@ -100,7 +100,7 @@ unsigned int bayerToMbusCode(const BayerFormat &bayer) uint32_t mbusCodeUnpacked16(unsigned int code) { BayerFormat bayer = BayerFormat::fromMbusCode(code); - BayerFormat bayer16(bayer.order, 16, BayerFormat::Packing::None); + BayerFormat bayer16(bayer.cfa.order, 16, BayerFormat::Packing::None); return bayerToMbusCode(bayer16); } @@ -109,16 +109,16 @@ uint8_t toPiSPBayerOrder(V4L2PixelFormat format) { BayerFormat bayer = BayerFormat::fromV4L2PixelFormat(format); - switch (bayer.order) { - case BayerFormat::Order::BGGR: + switch (bayer.cfa.order) { + case ColorFilterArray::Order::BGGR: return PISP_BAYER_ORDER_BGGR; - case BayerFormat::Order::GBRG: + case ColorFilterArray::Order::GBRG: return PISP_BAYER_ORDER_GBRG; - case BayerFormat::Order::GRBG: + case ColorFilterArray::Order::GRBG: return PISP_BAYER_ORDER_GRBG; - case BayerFormat::Order::RGGB: + case ColorFilterArray::Order::RGGB: return PISP_BAYER_ORDER_RGGB; - case BayerFormat::Order::MONO: + case ColorFilterArray::Order::MONO: return PISP_BAYER_ORDER_GREYSCALE; default: ASSERT(0); diff --git a/src/libcamera/pipeline/simple/simple.cpp b/src/libcamera/pipeline/simple/simple.cpp index 35c29ceca1bb..816759632976 100644 --- a/src/libcamera/pipeline/simple/simple.cpp +++ b/src/libcamera/pipeline/simple/simple.cpp @@ -32,6 +32,7 @@ #include <libcamera/pixel_format.h> #include <libcamera/stream.h> +#include "libcamera/internal/bayer_format.h" #include "libcamera/internal/camera.h" #include "libcamera/internal/camera_manager.h" #include "libcamera/internal/camera_sensor.h" @@ -1534,7 +1535,7 @@ int SimplePipelineHandler::configure(Camera *camera, CameraConfiguration *c) * pattern. */ BayerFormat cfgBayer = BayerFormat::fromPixelFormat(pipeConfig->captureFormat); - cfgBayer.order = data->sensor_->bayerOrder(config->combinedTransform()); + cfgBayer.cfa.order = data->sensor_->bayerOrder(config->combinedTransform()); videoFormat = cfgBayer.toV4L2PixelFormat(); } diff --git a/src/libcamera/sensor/camera_sensor_legacy.cpp b/src/libcamera/sensor/camera_sensor_legacy.cpp index cf7410bcee4c..8f47b77dc7c4 100644 --- a/src/libcamera/sensor/camera_sensor_legacy.cpp +++ b/src/libcamera/sensor/camera_sensor_legacy.cpp @@ -12,6 +12,7 @@ #include <limits.h> #include <map> #include <memory> +#include <optional> #include <string.h> #include <string> #include <vector> @@ -21,6 +22,7 @@ #include <libcamera/base/utils.h> #include <libcamera/camera.h> +#include <libcamera/color_filter_array.h> #include <libcamera/control_ids.h> #include <libcamera/controls.h> #include <libcamera/geometry.h> @@ -41,7 +43,6 @@ namespace libcamera { -class BayerFormat; class CameraLens; class MediaEntity; class SensorConfiguration; @@ -88,7 +89,7 @@ public: const ControlList &properties() const override { return properties_; } int sensorInfo(IPACameraSensorInfo *info) const override; Transform computeTransform(Orientation *orientation) const override; - BayerFormat::Order bayerOrder(Transform t) const override; + ColorFilterArray bayerOrder(Transform t) const override; Orientation mountingOrientation() const override { return mountingOrientation_; } const ControlInfoMap &controls() const override; @@ -134,7 +135,7 @@ private: Rectangle pixelArrayArea_; Rectangle readableArea_; Rectangle activeArea_; - const BayerFormat *bayerFormat_; + std::optional<ColorFilterArray> cfa_; bool supportHFlips_; bool supportVFlips_; bool flipsAlterBayerOrder_; @@ -156,7 +157,7 @@ private: CameraSensorLegacy::CameraSensorLegacy(const MediaEntity *entity) : entity_(entity), pad_(UINT_MAX), staticProps_(nullptr), - bayerFormat_(nullptr), supportHFlips_(false), supportVFlips_(false), + cfa_(std::nullopt), supportHFlips_(false), supportVFlips_(false), flipsAlterBayerOrder_(false), properties_(properties::properties) { } @@ -264,9 +265,9 @@ int CameraSensorLegacy::init() /* Get the color filter array pattern (only for RAW sensors). */ for (unsigned int mbusCode : mbusCodes_) { - const BayerFormat &bayerFormat = BayerFormat::fromMbusCode(mbusCode); - if (bayerFormat.isValid()) { - bayerFormat_ = &bayerFormat; + auto cfa = ColorFilterArray::fromMbusCode(mbusCode); + if (cfa) { + cfa_ = *cfa; break; } } @@ -445,7 +446,7 @@ int CameraSensorLegacy::validateSensorDriver() << "See Documentation/sensor_driver_requirements.rst in the libcamera sources for more information"; } - if (!bayerFormat_) + if (!cfa_) return 0; /* @@ -640,22 +641,22 @@ int CameraSensorLegacy::initProperties() properties_.set(properties::PixelArrayActiveAreas, { activeArea_ }); /* Color filter array pattern, register only for RAW sensors. */ - if (bayerFormat_) { + if (cfa_) { int32_t cfa; - switch (bayerFormat_->order) { - case BayerFormat::BGGR: + switch (cfa_->order) { + case ColorFilterArray::BGGR: cfa = properties::draft::BGGR; break; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: cfa = properties::draft::GBRG; break; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: cfa = properties::draft::GRBG; break; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: cfa = properties::draft::RGGB; break; - case BayerFormat::MONO: + case ColorFilterArray::MONO: cfa = properties::draft::MONO; break; } @@ -881,7 +882,7 @@ V4L2Subdevice::Stream CameraSensorLegacy::imageStream() const int CameraSensorLegacy::sensorInfo(IPACameraSensorInfo *info) const { - if (!bayerFormat_) + if (!cfa_) return -EINVAL; info->model = model(); @@ -982,20 +983,20 @@ Transform CameraSensorLegacy::computeTransform(Orientation *orientation) const return transform; } -BayerFormat::Order CameraSensorLegacy::bayerOrder(Transform t) const +ColorFilterArray CameraSensorLegacy::bayerOrder(Transform t) const { /* Return a defined by meaningless value for non-Bayer sensors. */ - if (!bayerFormat_) - return BayerFormat::Order::BGGR; + if (!cfa_) + return ColorFilterArray::BGGR; if (!flipsAlterBayerOrder_) - return bayerFormat_->order; + return *cfa_; /* * Apply the transform to the native (i.e. untransformed) Bayer order, * using the rest of the Bayer format supplied by the caller. */ - return bayerFormat_->transform(t).order; + return cfa_->transform(t); } const ControlInfoMap &CameraSensorLegacy::controls() const diff --git a/src/libcamera/sensor/camera_sensor_raw.cpp b/src/libcamera/sensor/camera_sensor_raw.cpp index 5301bc6d9f8c..c703db31d658 100644 --- a/src/libcamera/sensor/camera_sensor_raw.cpp +++ b/src/libcamera/sensor/camera_sensor_raw.cpp @@ -22,6 +22,7 @@ #include <libcamera/base/utils.h> #include <libcamera/camera.h> +#include <libcamera/color_filter_array.h> #include <libcamera/control_ids.h> #include <libcamera/controls.h> #include <libcamera/geometry.h> @@ -42,7 +43,6 @@ namespace libcamera { -class BayerFormat; class CameraLens; class MediaEntity; class SensorConfiguration; @@ -93,7 +93,7 @@ public: const ControlList &properties() const override { return properties_; } int sensorInfo(IPACameraSensorInfo *info) const override; Transform computeTransform(Orientation *orientation) const override; - BayerFormat::Order bayerOrder(Transform t) const override; + ColorFilterArray bayerOrder(Transform t) const override; Orientation mountingOrientation() const override { return mountingOrientation_; } const ControlInfoMap &controls() const override; @@ -144,7 +144,7 @@ private: Rectangle pixelArrayArea_; Rectangle readableArea_; Rectangle activeArea_; - BayerFormat::Order cfaPattern_; + ColorFilterArray cfa_; bool supportHFlips_; bool supportVFlips_; bool flipsAlterBayerOrder_; @@ -489,16 +489,19 @@ std::optional<int> CameraSensorRaw::init() switch (cfaPattern) { case V4L2_CFA_PATTERN_GRBG: - cfaPattern_ = BayerFormat::GRBG; + cfa_ = ColorFilterArray::GRBG; break; case V4L2_CFA_PATTERN_RGGB: - cfaPattern_ = BayerFormat::RGGB; + cfa_ = ColorFilterArray::RGGB; break; case V4L2_CFA_PATTERN_BGGR: - cfaPattern_ = BayerFormat::BGGR; + cfa_ = ColorFilterArray::BGGR; break; case V4L2_CFA_PATTERN_GBRG: - cfaPattern_ = BayerFormat::GBRG; + cfa_ = ColorFilterArray::GBRG; + break; + case V4L2_CFA_PATTERN_MONO: + cfa_ = ColorFilterArray::MONO; break; default: LOG(CameraSensor, Error) @@ -667,20 +670,20 @@ int CameraSensorRaw::initProperties() /* Color filter array pattern. */ uint32_t cfa; - switch (cfaPattern_) { - case BayerFormat::BGGR: + switch (cfa_.order) { + case ColorFilterArray::BGGR: cfa = properties::draft::BGGR; break; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: cfa = properties::draft::GBRG; break; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: cfa = properties::draft::GRBG; break; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: cfa = properties::draft::RGGB; break; - case BayerFormat::MONO: + case ColorFilterArray::MONO: default: cfa = properties::draft::MONO; break; @@ -1112,17 +1115,16 @@ Transform CameraSensorRaw::computeTransform(Orientation *orientation) const return transform; } -BayerFormat::Order CameraSensorRaw::bayerOrder(Transform t) const +ColorFilterArray CameraSensorRaw::bayerOrder(Transform t) const { if (!flipsAlterBayerOrder_) - return cfaPattern_; + return cfa_; /* * Apply the transform to the native (i.e. untransformed) Bayer order, * using the rest of the Bayer format supplied by the caller. */ - BayerFormat format{ cfaPattern_, 8, BayerFormat::Packing::None }; - return format.transform(t).order; + return cfa_.transform(t); } const ControlInfoMap &CameraSensorRaw::controls() const diff --git a/src/libcamera/software_isp/debayer.cpp b/src/libcamera/software_isp/debayer.cpp index 4f6659000edb..9862f4e29538 100644 --- a/src/libcamera/software_isp/debayer.cpp +++ b/src/libcamera/software_isp/debayer.cpp @@ -330,13 +330,13 @@ void Debayer::dmaSyncBegin(std::vector<DmaSyncer> &dmaSyncers, FrameBuffer *inpu } /** - * \fn void Debayer::isStandardBayerOrder(BayerFormat::Order order) + * \fn void Debayer::isStandardBayerOrder(ColorFilterArray::Order order) * \brief Common method to validate standard 2x2 Bayer pattern of 2 Green, 1 Blue, 1 Red pixels */ -bool Debayer::isStandardBayerOrder(BayerFormat::Order order) +bool Debayer::isStandardBayerOrder(ColorFilterArray::Order order) { - return order == BayerFormat::BGGR || order == BayerFormat::GBRG || - order == BayerFormat::GRBG || order == BayerFormat::RGGB; + return order == ColorFilterArray::BGGR || order == ColorFilterArray::GBRG || + order == ColorFilterArray::GRBG || order == ColorFilterArray::RGGB; } } /* namespace libcamera */ diff --git a/src/libcamera/software_isp/debayer.h b/src/libcamera/software_isp/debayer.h index e30a05279c18..d5240a1e42a2 100644 --- a/src/libcamera/software_isp/debayer.h +++ b/src/libcamera/software_isp/debayer.h @@ -87,7 +87,7 @@ private: protected: void dmaSyncBegin(std::vector<DmaSyncer> &dmaSyncers, FrameBuffer *input, FrameBuffer *output); - static bool isStandardBayerOrder(BayerFormat::Order order); + static bool isStandardBayerOrder(ColorFilterArray::Order order); }; } /* namespace libcamera */ diff --git a/src/libcamera/software_isp/debayer_cpu.cpp b/src/libcamera/software_isp/debayer_cpu.cpp index 91867baa656a..56850a7b30c7 100644 --- a/src/libcamera/software_isp/debayer_cpu.cpp +++ b/src/libcamera/software_isp/debayer_cpu.cpp @@ -442,7 +442,7 @@ int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if ((bayerFormat.bitDepth == 8 || bayerFormat.bitDepth == 10 || bayerFormat.bitDepth == 12) && bayerFormat.packing == BayerFormat::Packing::None && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = (bayerFormat.bitDepth + 7) & ~7; config.patternSize.width = 2; config.patternSize.height = 2; @@ -452,7 +452,7 @@ int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if (bayerFormat.bitDepth == 10 && bayerFormat.packing == BayerFormat::Packing::CSI2 && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = 10; config.patternSize.width = 4; /* 5 bytes per *4* pixels */ config.patternSize.height = 2; @@ -462,7 +462,7 @@ int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if (bayerFormat.bitDepth == 12 && bayerFormat.packing == BayerFormat::Packing::CSI2 && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = 12; config.patternSize.width = 2; /* 3 bytes per *2* pixels */ config.patternSize.height = 2; @@ -479,18 +479,18 @@ int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf * Check for standard Bayer orders and set xShift_ and swap debayer0/1, so that * a single pair of BGGR debayer functions can be used for all 4 standard orders. */ -int DebayerCpu::setupStandardBayerOrder(BayerFormat::Order order) +int DebayerCpu::setupStandardBayerOrder(ColorFilterArray::Order order) { switch (order) { - case BayerFormat::BGGR: + case ColorFilterArray::BGGR: break; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: xShift_ = 1; /* BGGR -> GBRG */ break; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: std::swap(debayer0_, debayer1_); /* BGGR -> GRBG */ break; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: xShift_ = 1; /* BGGR -> GBRG */ std::swap(debayer0_, debayer1_); /* GBRG -> RGGB */ break; @@ -540,18 +540,18 @@ int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat, /* Swap R and B in bayer order to generate BGR888 instead of RGB888 */ swapRedBlueGains_ = true; - switch (bayerFormat.order) { - case BayerFormat::BGGR: - bayerFormat.order = BayerFormat::RGGB; + switch (bayerFormat.cfa.order) { + case ColorFilterArray::BGGR: + bayerFormat.cfa.order = ColorFilterArray::RGGB; break; - case BayerFormat::GBRG: - bayerFormat.order = BayerFormat::GRBG; + case ColorFilterArray::GBRG: + bayerFormat.cfa.order = ColorFilterArray::GRBG; break; - case BayerFormat::GRBG: - bayerFormat.order = BayerFormat::GBRG; + case ColorFilterArray::GRBG: + bayerFormat.cfa.order = ColorFilterArray::GBRG; break; - case BayerFormat::RGGB: - bayerFormat.order = BayerFormat::BGGR; + case ColorFilterArray::RGGB: + bayerFormat.cfa.order = ColorFilterArray::BGGR; break; default: return invalidFmt(); @@ -563,7 +563,7 @@ int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat, if ((bayerFormat.bitDepth == 8 || bayerFormat.bitDepth == 10 || bayerFormat.bitDepth == 12) && bayerFormat.packing == BayerFormat::Packing::None && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { switch (bayerFormat.bitDepth) { case 8: SET_DEBAYER_METHODS(debayer8_BGBG_BGR888, debayer8_GRGR_BGR888) @@ -575,23 +575,23 @@ int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat, SET_DEBAYER_METHODS(debayer12_BGBG_BGR888, debayer12_GRGR_BGR888) break; } - setupStandardBayerOrder(bayerFormat.order); + setupStandardBayerOrder(bayerFormat.cfa.order); return 0; } if (bayerFormat.bitDepth == 10 && bayerFormat.packing == BayerFormat::Packing::CSI2) { - switch (bayerFormat.order) { - case BayerFormat::BGGR: + switch (bayerFormat.cfa.order) { + case ColorFilterArray::BGGR: SET_DEBAYER_METHODS(debayer10P_BGBG_BGR888, debayer10P_GRGR_BGR888) return 0; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: SET_DEBAYER_METHODS(debayer10P_GBGB_BGR888, debayer10P_RGRG_BGR888) return 0; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: SET_DEBAYER_METHODS(debayer10P_GRGR_BGR888, debayer10P_BGBG_BGR888) return 0; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: SET_DEBAYER_METHODS(debayer10P_RGRG_BGR888, debayer10P_GBGB_BGR888) return 0; default: @@ -601,17 +601,17 @@ int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat, if (bayerFormat.bitDepth == 12 && bayerFormat.packing == BayerFormat::Packing::CSI2) { - switch (bayerFormat.order) { - case BayerFormat::BGGR: + switch (bayerFormat.cfa.order) { + case ColorFilterArray::BGGR: SET_DEBAYER_METHODS(debayer12P_BGBG_BGR888, debayer12P_GRGR_BGR888) return 0; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: SET_DEBAYER_METHODS(debayer12P_GBGB_BGR888, debayer12P_RGRG_BGR888) return 0; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: SET_DEBAYER_METHODS(debayer12P_GRGR_BGR888, debayer12P_BGBG_BGR888) return 0; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: SET_DEBAYER_METHODS(debayer12P_RGRG_BGR888, debayer12P_GBGB_BGR888) return 0; default: diff --git a/src/libcamera/software_isp/debayer_cpu.h b/src/libcamera/software_isp/debayer_cpu.h index ae570893bf13..8e27cbae4763 100644 --- a/src/libcamera/software_isp/debayer_cpu.h +++ b/src/libcamera/software_isp/debayer_cpu.h @@ -122,7 +122,7 @@ private: void debayer12P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[]); static int getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config); - int setupStandardBayerOrder(BayerFormat::Order order); + int setupStandardBayerOrder(ColorFilterArray::Order order); int setDebayerFunctions(PixelFormat inputFormat, PixelFormat outputFormat, bool ccmEnabled); diff --git a/src/libcamera/software_isp/debayer_egl.cpp b/src/libcamera/software_isp/debayer_egl.cpp index 33933b11db70..3f3d2d5f0763 100644 --- a/src/libcamera/software_isp/debayer_egl.cpp +++ b/src/libcamera/software_isp/debayer_egl.cpp @@ -63,7 +63,7 @@ int DebayerEGL::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if ((bayerFormat.bitDepth == 8 || bayerFormat.bitDepth == 10) && bayerFormat.packing == BayerFormat::Packing::None && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = (bayerFormat.bitDepth + 7) & ~7; config.patternSize.width = 2; config.patternSize.height = 2; @@ -73,7 +73,7 @@ int DebayerEGL::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if (bayerFormat.bitDepth == 10 && bayerFormat.packing == BayerFormat::Packing::CSI2 && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = 10; config.patternSize.width = 4; /* 5 bytes per *4* pixels */ config.patternSize.height = 2; @@ -83,7 +83,7 @@ int DebayerEGL::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf if (bayerFormat.bitDepth == 12 && bayerFormat.packing == BayerFormat::Packing::CSI2 && - isStandardBayerOrder(bayerFormat.order)) { + isStandardBayerOrder(bayerFormat.cfa.order)) { config.bpp = 12; config.patternSize.width = 2; /* 3 bytes per *2* pixels */ config.patternSize.height = 2; diff --git a/src/libcamera/software_isp/swstats_cpu.cpp b/src/libcamera/software_isp/swstats_cpu.cpp index 7fb77ce7ddd6..58503f30a818 100644 --- a/src/libcamera/software_isp/swstats_cpu.cpp +++ b/src/libcamera/software_isp/swstats_cpu.cpp @@ -429,22 +429,22 @@ void SwStatsCpu::finishFrame(uint32_t frame, uint32_t bufferId) * Check if order is a standard Bayer order and setup xShift_ and swapLines_ * so that a single BGGR stats function can be used for all 4 standard orders. */ -int SwStatsCpu::setupStandardBayerOrder(BayerFormat::Order order) +int SwStatsCpu::setupStandardBayerOrder(ColorFilterArray::Order order) { switch (order) { - case BayerFormat::BGGR: + case ColorFilterArray::BGGR: xShift_ = 0; swapLines_ = false; break; - case BayerFormat::GBRG: + case ColorFilterArray::GBRG: xShift_ = 1; /* BGGR -> GBRG */ swapLines_ = false; break; - case BayerFormat::GRBG: + case ColorFilterArray::GRBG: xShift_ = 0; swapLines_ = true; /* BGGR -> GRBG */ break; - case BayerFormat::RGGB: + case ColorFilterArray::RGGB: xShift_ = 1; /* BGGR -> GBRG */ swapLines_ = true; /* GBRG -> RGGB */ break; @@ -474,7 +474,7 @@ int SwStatsCpu::configure(const StreamConfiguration &inputCfg, unsigned int stat BayerFormat::fromPixelFormat(inputCfg.pixelFormat); if (bayerFormat.packing == BayerFormat::Packing::None && - setupStandardBayerOrder(bayerFormat.order) == 0) { + setupStandardBayerOrder(bayerFormat.cfa.order) == 0) { processFrame_ = &SwStatsCpu::processBayerFrame2; switch (bayerFormat.bitDepth) { case 8: @@ -509,16 +509,16 @@ int SwStatsCpu::configure(const StreamConfiguration &inputCfg, unsigned int stat sumShift_ = 0; processFrame_ = &SwStatsCpu::processBayerFrame2; - switch (bayerFormat.order) { - case BayerFormat::BGGR: - case BayerFormat::GRBG: + switch (bayerFormat.cfa.order) { + case ColorFilterArray::BGGR: + case ColorFilterArray::GRBG: stats0_ = (bitDepth == 10) ? &SwStatsCpu::statsBGGR10PLine0 : &SwStatsCpu::statsBGGR12PLine0; - swapLines_ = bayerFormat.order == BayerFormat::GRBG; + swapLines_ = bayerFormat.cfa.order == ColorFilterArray::GRBG; return 0; - case BayerFormat::GBRG: - case BayerFormat::RGGB: + case ColorFilterArray::GBRG: + case ColorFilterArray::RGGB: stats0_ = (bitDepth == 10) ? &SwStatsCpu::statsGBRG10PLine0 : &SwStatsCpu::statsGBRG12PLine0; - swapLines_ = bayerFormat.order == BayerFormat::RGGB; + swapLines_ = bayerFormat.cfa.order == ColorFilterArray::RGGB; return 0; default: break; diff --git a/test/bayer-format.cpp b/test/bayer-format.cpp index f8d1980498c1..3ff7d3bfab97 100644 --- a/test/bayer-format.cpp +++ b/test/bayer-format.cpp @@ -30,7 +30,7 @@ protected: } /* A correct Bayer format has to be valid. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); if (!bayerFmt.isValid()) { cerr << "A correct BayerFormat has to be valid." << endl; @@ -41,8 +41,8 @@ protected: * Two bayer formats created with the same order and bit depth * have to be equal. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); - BayerFormat bayerFmtExpect = BayerFormat(BayerFormat::BGGR, 8, + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); + BayerFormat bayerFmtExpect = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); if (bayerFmt != bayerFmtExpect) { cerr << "Comparison of identical formats failed." @@ -54,8 +54,8 @@ protected: * Two Bayer formats created with the same order but with a * different bitDepth are not equal. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); - bayerFmtExpect = BayerFormat(BayerFormat::BGGR, 12, + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); + bayerFmtExpect = BayerFormat(ColorFilterArray::BGGR, 12, BayerFormat::Packing::None); if (bayerFmt == bayerFmtExpect) { cerr << "Comparison of different formats failed." @@ -95,7 +95,7 @@ protected: * when we convert the V4L2PixelFormat (V4L2_PIX_FMT_SBGGR8) * to a Bayer format. */ - bayerFmtExpect = BayerFormat(BayerFormat::BGGR, 8, + bayerFmtExpect = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); v4l2Fmt = V4L2PixelFormat(V4L2_PIX_FMT_SBGGR8); bayerFmt = BayerFormat::fromV4L2PixelFormat(v4l2Fmt); @@ -123,7 +123,7 @@ protected: * Test if a valid Bayer format can be converted to a * string representation. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); if (bayerFmt.toString() != "BGGR-8") { cerr << "String representation != 'BGGR-8' (got: '" << bayerFmt.toString() << "' ) " << endl; @@ -145,10 +145,11 @@ protected: * Perform a horizontal Flip and make sure that the * order is adjusted accordingly. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); - bayerFmtExpect = BayerFormat(BayerFormat::GBRG, 8, + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); + bayerFmtExpect = BayerFormat(ColorFilterArray::GBRG, 8, BayerFormat::Packing::None); - BayerFormat hFlipFmt = bayerFmt.transform(Transform::HFlip); + BayerFormat hFlipFmt = bayerFmt; + hFlipFmt.cfa = bayerFmt.cfa.transform(Transform::HFlip); if (hFlipFmt != bayerFmtExpect) { cerr << "Horizontal flip of 'BGGR-8' should result in '" << bayerFmtExpect << "', got: '" @@ -160,10 +161,11 @@ protected: * Perform a vertical Flip and make sure that * the order is adjusted accordingly. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); - bayerFmtExpect = BayerFormat(BayerFormat::GRBG, 8, + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); + bayerFmtExpect = BayerFormat(ColorFilterArray::GRBG, 8, BayerFormat::Packing::None); - BayerFormat vFlipFmt = bayerFmt.transform(Transform::VFlip); + BayerFormat vFlipFmt = bayerFmt; + vFlipFmt.cfa = bayerFmt.cfa.transform(Transform::VFlip); if (vFlipFmt != bayerFmtExpect) { cerr << "Vertical flip of 'BGGR-8' should result in '" << bayerFmtExpect << "', got: '" @@ -176,9 +178,9 @@ protected: * pixels on the bottom left to top right diagonal and make * sure, that it doesn't change. */ - bayerFmt = BayerFormat(BayerFormat::BGGR, 8, BayerFormat::Packing::None); - BayerFormat transposeFmt = bayerFmt.transform( - Transform::Transpose); + bayerFmt = BayerFormat(ColorFilterArray::BGGR, 8, BayerFormat::Packing::None); + BayerFormat transposeFmt = bayerFmt; + transposeFmt.cfa = bayerFmt.cfa.transform( Transform::Transpose); if (transposeFmt != bayerFmt) { cerr << "Transpose with both green pixels on the " << "antidiagonal should not change the order " @@ -192,10 +194,10 @@ protected: * on the bottom left to top right diagonal and make sure * that their positions are switched. */ - bayerFmt = BayerFormat(BayerFormat::GBRG, 8, BayerFormat::Packing::None); - bayerFmtExpect = BayerFormat(BayerFormat::GRBG, 8, + bayerFmt = BayerFormat(ColorFilterArray::GBRG, 8, BayerFormat::Packing::None); + bayerFmtExpect = BayerFormat(ColorFilterArray::GRBG, 8, BayerFormat::Packing::None); - transposeFmt = bayerFmt.transform(Transform::Transpose); + transposeFmt.cfa = bayerFmt.cfa.transform(Transform::Transpose); if (transposeFmt != bayerFmtExpect) { cerr << "Transpose with the red & blue pixels on the " << "antidiagonal should switch their position "

[WIP,RFC,12/26] libcamera: bayer_format: Introduce a ColorFilterArray class
diff mbox series

Commit Message

Patch
diff mbox series

[WIP,RFC,12/26] libcamera: bayer_format: Introduce a ColorFilterArray class 28582 diff mbox series

Commit Message

Patch 28582 diff mbox series

[WIP,RFC,12/26] libcamera: bayer_format: Introduce a ColorFilterArray class
diff mbox series

Patch
diff mbox series