From patchwork Fri May 1 10:52:06 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Max Bretschneider X-Patchwork-Id: 26589 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 2445BC32F6 for ; Fri, 1 May 2026 10:52:13 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 3A69062FE8; Fri, 1 May 2026 12:52:11 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (2048-bit key; unprotected) header.d=protonmail.com header.i=@protonmail.com header.b="tHHOeJyh"; dkim-atps=neutral Received: from mail-24431.protonmail.ch (mail-24431.protonmail.ch [109.224.244.31]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id DB13B62FB1 for ; Fri, 1 May 2026 12:52:09 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=protonmail.com; s=protonmail3; t=1777632729; x=1777891929; bh=A2NHwKtarGnPMpJP6OwQv3aTHbgDJHF4mxqq8z6MZgQ=; h=Date:To:From:Cc:Subject:Message-ID:In-Reply-To:References: Feedback-ID:From:To:Cc:Date:Subject:Reply-To:Feedback-ID: Message-ID:BIMI-Selector; b=tHHOeJyhq1+OVumfnlT6LrpJIWOPqrTdN/tr3aQMALjqzEAqRImMc+lCmrhmP3P5e 2T/nAhCw117exUrJXN3SG/NIhzFtUZq83y9pe4LK6DILUdZIuIMi3yN342cb+FvRoG kTR912SetckG9a9lrTJKXJOFIPOKFKOAX83tR/CSwfvvqWRuwchpIg0sFynF6nT7Nl wgfw9zwCzZlvbJChSBoIyLWQKIjLoAbNKM+YqqTJw9HbQrEahXVRJN0iBoLac47fag Yt7CL9k4MGBTeIZZclaVWXotOyazzmZiG2814U2CDGBcAiIeQLe0TbetOC+/LuxUP6 i6Og2+XnKDH7A== Date: Fri, 01 May 2026 10:52:06 +0000 To: libcamera-devel@lists.libcamera.org From: Max Bretschneider Cc: Max Bretschneider Subject: [RFC PATCH v1 1/3] libcamera: pipeline: virtual: Add RawFrameGenerator Message-ID: <20260501105137.439519-2-maxbretschneider@protonmail.com> In-Reply-To: <20260501105137.439519-1-maxbretschneider@protonmail.com> References: <20260501105137.439519-1-maxbretschneider@protonmail.com> Feedback-ID: 122687743:user:proton X-Pm-Message-ID: fc042eac895cfb37f83f64a2de269e9db950978e MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Added a new FrameGenerator subclass which reads binary raw Bayer files from disk and copies them into the output FrameBuffers unchanged. No format conversion is performed. Input files must be plain binary sensor dumps without a header, and they must match the declared bayer_order and bit_depht. Modelled on ImageFrameGenerator. Signed-off-by: Max Bretschneider --- src/libcamera/pipeline/virtual/meson.build | 1 + .../pipeline/virtual/raw_frame_generator.cpp | 131 ++++++++++++++++++ .../pipeline/virtual/raw_frame_generator.h | 47 +++++++ 3 files changed, 179 insertions(+) create mode 100644 src/libcamera/pipeline/virtual/raw_frame_generator.cpp create mode 100644 src/libcamera/pipeline/virtual/raw_frame_generator.h -- 2.43.0 diff --git a/src/libcamera/pipeline/virtual/meson.build b/src/libcamera/pipeline/virtual/meson.build index c8434593..c6576142 100644 --- a/src/libcamera/pipeline/virtual/meson.build +++ b/src/libcamera/pipeline/virtual/meson.build @@ -3,6 +3,7 @@ libcamera_internal_sources += files([ 'config_parser.cpp', 'image_frame_generator.cpp', + 'raw_frame_generator.cpp', 'test_pattern_generator.cpp', 'virtual.cpp', ]) diff --git a/src/libcamera/pipeline/virtual/raw_frame_generator.cpp b/src/libcamera/pipeline/virtual/raw_frame_generator.cpp new file mode 100644 index 00000000..e0be28cf --- /dev/null +++ b/src/libcamera/pipeline/virtual/raw_frame_generator.cpp @@ -0,0 +1,131 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, max.bretschneider@leica-geosystems.com + * + * Derived class of FrameGenerator for generating raw Bayer frames + */ + +#include "raw_frame_generator.h" + +#include +#include + +#include +#include + +#include + +#include "libcamera/internal/mapped_framebuffer.h" + +namespace libcamera { + +LOG_DECLARE_CATEGORY(Virtual) + +/* + * Factory function to create a RawFrameGenerator object. + * Read the raw Bayer frames from disk and store them in memory. + */ +std::unique_ptr +RawFrameGenerator::create(RawFrames &rawFrames) +{ + std::unique_ptr rawFrameGenerator = + std::make_unique(); + + /* + * For each file in the directory, load the raw frame + * and store it. No format conversion is performed, but + * raw Bayer bytes are stored as-is. + */ + for (const auto &path : rawFrames.files) { + File file(path); + if (!file.open(File::OpenModeFlag::ReadOnly)) { + LOG(Virtual, Error) << "Failed to open raw frame file " + << file.fileName() + << ": " << strerror(file.error()); + return nullptr; + } + + auto fileSize = file.size(); + auto buffer = std::make_unique(fileSize); + if (file.read({ buffer.get(), static_cast(fileSize) }) != fileSize) { + LOG(Virtual, Error) << "Failed to read raw frame file " + << file.fileName() + << ": " << strerror(file.error()); + return nullptr; + } + + rawFrameGenerator->framesDatas_.emplace_back( + RawFrameData{ std::move(buffer), static_cast(fileSize) }); + } + + ASSERT(!rawFrameGenerator->framesDatas_.empty()); + + return rawFrameGenerator; +} + +void RawFrameGenerator::configure(const Size & /*size*/) +{ + /* + * Raw frames cannot be scaled, the configured size is not used for + * processing but mismatches are caught in generateFrame(). + */ + frameIndex_ = 0; + parameter_ = 0; +} + +int RawFrameGenerator::generateFrame(const Size & /*size*/, const FrameBuffer *buffer) +{ + ASSERT(!framesDatas_.empty()); + + MappedFrameBuffer mappedFrameBuffer(buffer, + MappedFrameBuffer::MapFlag::Write); + + const auto &planes = mappedFrameBuffer.planes(); + + /* Loop only around the number of frames available */ + frameIndex_ %= framesDatas_.size(); + + const auto &frame = framesDatas_[frameIndex_]; + + /* + * Raw Bayer frames must exactly match the configured output size. + * They cannot be scaled to fit. + */ + if (frame.size != planes[0].size()) { + LOG(Virtual, Error) << "Raw frame size mismatch: file has " + << frame.size << " bytes, buffer expects " + << planes[0].size() << " bytes"; + return -EINVAL; + } + + memcpy(planes[0].data(), frame.data.get(), frame.size); + + /* Proceed to the next frame on every request */ + parameter_++; + if (parameter_ % frameRepeat == 0) { + frameIndex_++; + } + + return 0; +} + +/* + * \var RawFrameGenerator::frameRepeat + * \brief Number of frames to repeat before proceeding to the next frame + */ + +/* + * \var RawFrameGenerator::framesDatas_ + * \brief List of raw Bayer frame buffers loaded from disk + */ + +/* \var RawFrameGenerator::frameIndex_ + * \brief Index of the current frame in framesDatas_ + */ + +/* + * \var RawFrameGenerator::parameter_ + * \brief Counter used to implement frameRepeat behaviour + */ + +} /* namespace libcamera */ diff --git a/src/libcamera/pipeline/virtual/raw_frame_generator.h b/src/libcamera/pipeline/virtual/raw_frame_generator.h new file mode 100644 index 00000000..d711a47d --- /dev/null +++ b/src/libcamera/pipeline/virtual/raw_frame_generator.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2026, max.bretschneider@leica-geosystems.com + * + * Raw Bayer frame generator for the virtual pipeline handler + */ + +#pragma once + +#include +#include +#include +#include + +#include "frame_generator.h" + +namespace libcamera { + +/* Frame configuration provided by the config file */ +struct RawFrames { + std::vector files; + uint32_t cfaPattern; + unsigned int bitDepth; +}; + +class RawFrameGenerator : public FrameGenerator +{ +public: + static std::unique_ptr create(RawFrames &rawFrames); + +private: + static constexpr unsigned int frameRepeat = 1; /*advance every frame*/ + + struct RawFrameData { + std::unique_ptr data; + size_t size; + }; + + void configure(const Size &size) override; + int generateFrame(const Size &size, const FrameBuffer *buffer) override; + + std::vector framesDatas_; + unsigned int frameIndex_; + unsigned int parameter_; +}; + +} /* namespace libcamera */ From patchwork Fri May 1 10:52:09 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Max Bretschneider X-Patchwork-Id: 26590 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 2D03EBDCB5 for ; Fri, 1 May 2026 10:52:15 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id C9B6263021; Fri, 1 May 2026 12:52:14 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (2048-bit key; unprotected) header.d=protonmail.com header.i=@protonmail.com header.b="hcntd6rX"; dkim-atps=neutral Received: from mail-10699.protonmail.ch (mail-10699.protonmail.ch [79.135.106.99]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 0825862FD3 for ; Fri, 1 May 2026 12:52:14 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=protonmail.com; s=protonmail3; t=1777632733; x=1777891933; bh=iYQHAUY6USdU+wdz5n70UaFjuzvcs5UlQwruuIUMZLg=; h=Date:To:From:Cc:Subject:Message-ID:In-Reply-To:References: Feedback-ID:From:To:Cc:Date:Subject:Reply-To:Feedback-ID: Message-ID:BIMI-Selector; b=hcntd6rXXMonUNqfHDG7CVPbRAYTRvgAAHoqD/G9Y+NniZ5xFcI4GruXjidFN6eL/ ScDWnSFnU8kq0TSQkTYfGvphzGKUjJECNXasz7ClimQNY0tuWBvi5vjHHaOApaoCM9 1kpaIcbUhyzVUZcF4qmCNjaJYW+RopCOelo3OJA/9VJY1kmbChPA5/YPsoSasTK4oo 8NdrC9OKA28YI1AxVlA6T8ZC6aTOnty9JzRl43ea/Hk+Kjbb427uXCMRa6tsBJfKyK aZKbnw3iGrAvfOwyiSdYspIdrilKzKkwAV89LJ0W+E+5WjR0hjiJBo/gCDh2HuMr66 lrpLvU9PyZvDQ== Date: Fri, 01 May 2026 10:52:09 +0000 To: libcamera-devel@lists.libcamera.org From: Max Bretschneider Cc: Max Bretschneider Subject: [RFC PATCH v1 2/3] libcamera: pipeline: virtual: Add raw_frames config parser support Message-ID: <20260501105137.439519-3-maxbretschneider@protonmail.com> In-Reply-To: <20260501105137.439519-1-maxbretschneider@protonmail.com> References: <20260501105137.439519-1-maxbretschneider@protonmail.com> Feedback-ID: 122687743:user:proton X-Pm-Message-ID: 8124651386b37c98f5f4c49914ace05c35876a7d MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Extend parseFrameGenerator() to handle the new raw_frames YAML key alongside the existing test_pattern and frames keys. File collection logic (e.g. either single file or directory with natural sorting) follows the existing frames path handling. This raw_frames block accepts: - path (single file or directory) - bayer_order (RGGB, BGGR, GRBG, GBRG) - bit_depth (8, 10, 12, 14, 16), in accordance to libcamera/formats.yaml Signed-off-by: Max Bretschneider --- .../pipeline/virtual/config_parser.cpp | 100 ++++++++++++++++-- 1 file changed, 94 insertions(+), 6 deletions(-) -- 2.43.0 diff --git a/src/libcamera/pipeline/virtual/config_parser.cpp b/src/libcamera/pipeline/virtual/config_parser.cpp index 5169fd39..fcce70c8 100644 --- a/src/libcamera/pipeline/virtual/config_parser.cpp +++ b/src/libcamera/pipeline/virtual/config_parser.cpp @@ -156,13 +156,20 @@ int ConfigParser::parseFrameGenerator(const ValueNode &cameraConfigData, Virtual { const std::string testPatternKey = "test_pattern"; const std::string framesKey = "frames"; - if (cameraConfigData.contains(testPatternKey)) { - if (cameraConfigData.contains(framesKey)) { - LOG(Virtual, Error) << "A camera should use either " - << testPatternKey << " or " << framesKey; - return -EINVAL; - } + const std::string rawFramesKey = "raw_frames"; + + /* Ensure only one frame source is specified */ + int sourcesSpecified = cameraConfigData.contains(testPatternKey) + + cameraConfigData.contains(framesKey) + + cameraConfigData.contains(rawFramesKey); + if (sourcesSpecified > 1) { + LOG(Virtual, Error) << "A camera should use only one of " + << testPatternKey << ", " << framesKey + << ", or " << rawFramesKey; + return -EINVAL; + } + if (cameraConfigData.contains(testPatternKey)) { auto testPattern = cameraConfigData[testPatternKey].get(""); if (testPattern == "bars") { @@ -178,6 +185,87 @@ int ConfigParser::parseFrameGenerator(const ValueNode &cameraConfigData, Virtual return 0; } + if (cameraConfigData.contains(rawFramesKey)) { + const ValueNode &rawFrames = cameraConfigData[rawFramesKey]; + + if (!rawFrames.isDictionary()) { + LOG(Virtual, Error) << "'raw_frames' is not a dictionary."; + return -EINVAL; + } + + auto path = rawFrames["path"].get(); + if (!path) { + LOG(Virtual, Error) << "raw_frames: path must be specified."; + return -EINVAL; + } + + std::vector files; + + switch (std::filesystem::symlink_status(*path).type()) { + case std::filesystem::file_type::regular: + files.push_back(*path); + break; + + case std::filesystem::file_type::directory: + for (const auto &dentry : std::filesystem::directory_iterator{ *path }) + if (dentry.is_regular_file()) + files.push_back(dentry.path()); + + std::sort(files.begin(), files.end(), [](const auto &a, const auto &b) { + return ::strverscmp(a.c_str(), b.c_str()) < 0; + }); + + if (files.empty()) { + LOG(Virtual, Error) << "raw_frames directory has no files: " << *path; + return -EINVAL; + } + break; + default: + LOG(Virtual, Error) << "raw_frames path: " << *path << " is not supported"; + return -EINVAL; + } + + /* Parse bayer_order */ + auto bayerOrder = rawFrames["bayer_order"].get(); + if (!bayerOrder) { + LOG(Virtual, Error) << "raw_frames: bayer_order must be specified."; + return -EINVAL; + } + + static const std::map bayerOrderMap = { + { "RGGB", properties::draft::ColorFilterArrangementEnum::RGGB }, + { "BGGR", properties::draft::ColorFilterArrangementEnum::BGGR }, + { "GRBG", properties::draft::ColorFilterArrangementEnum::GRBG }, + { "GBRG", properties::draft::ColorFilterArrangementEnum::GBRG }, + }; + + auto it = bayerOrderMap.find(*bayerOrder); + if (it == bayerOrderMap.end()) { + LOG(Virtual, Error) << "raw_frames: unsupported bayer_order: " + << *bayerOrder + << ", must be one of RGGB, BGGR, GRBG, GBRG"; + return -EINVAL; + } + + /* Parse bit_depth */ + auto bitDepth = rawFrames["bit_depth"].get(); + if (!bitDepth) { + LOG(Virtual, Error) << "raw_frames: bit_depth must be specified."; + return -EINVAL; + } + + static const std::set supportedBitDepths = { 8, 10, 12, 14, 16 }; + if (supportedBitDepths.find(*bitDepth) == supportedBitDepths.end()) { + LOG(Virtual, Error) << "raw_frames: bit_depth unsupported: " << *bitDepth + << ", must be one of 8, 10, 12, 14, 16"; + return -EINVAL; + } + + data->config_.frame = RawFrames{ std::move(files), it->second, *bitDepth }; + + return 0; + } + const ValueNode &frames = cameraConfigData[framesKey]; /* When there is no frames provided in the config file, use color bar test pattern */ From patchwork Fri May 1 10:52:13 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Max Bretschneider X-Patchwork-Id: 26591 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 B81D2BDCB5 for ; Fri, 1 May 2026 10:52:20 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 661766301A; Fri, 1 May 2026 12:52:20 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (2048-bit key; unprotected) header.d=protonmail.com header.i=@protonmail.com header.b="UqC0zwWV"; dkim-atps=neutral Received: from mail-43166.protonmail.ch (mail-43166.protonmail.ch [185.70.43.166]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id A725B62FE8 for ; Fri, 1 May 2026 12:52:18 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=protonmail.com; s=protonmail3; t=1777632738; x=1777891938; bh=ZJPOY3/OwUQG4BZcbsfUxqqrPOe0aqRGxct2M8cNYEw=; h=Date:To:From:Cc:Subject:Message-ID:In-Reply-To:References: Feedback-ID:From:To:Cc:Date:Subject:Reply-To:Feedback-ID: Message-ID:BIMI-Selector; b=UqC0zwWVupwyTxL9Ct9aqFQiPp9rbdS3kLIbv1Z5rDdyEtt4+nI7XQ8etg5fVKmFt WzwyhhDd8p4EMxjI36nZnlEHL7bZNZpIF+V1swdJo7Orw9msRY/ObI7flYG1sfRoFe lcBHwWCs2qu7fT1wAPmtgVAtzvB1PYOqVO/CRojGREiZh7zn4czaEEo0Xabz/yGHFc 7koxeDzJ/mIwJ2zp1F8IlePEXGt9YfMQ+HD9OQER5xlABkdnfxinKawJluc93pnbU2 ZF5WZzXU1FecM8Mqqop6cSiI0HTk7rEN+tcYzkA2Zim3vrv7an2gG7bLnkhaGlOmVR cVkY1IuJRknNQ== Date: Fri, 01 May 2026 10:52:13 +0000 To: libcamera-devel@lists.libcamera.org From: Max Bretschneider Cc: Max Bretschneider Subject: [RFC PATCH v1 3/3] libcamera: pipeline: virtual: Support StreamRole::Raw and Bayer formats Message-ID: <20260501105137.439519-4-maxbretschneider@protonmail.com> In-Reply-To: <20260501105137.439519-1-maxbretschneider@protonmail.com> References: <20260501105137.439519-1-maxbretschneider@protonmail.com> Feedback-ID: 122687743:user:proton X-Pm-Message-ID: 90c2765669d8b9305bc89b33b05cb288f6a206ee MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Extend generateConfiguration() to return a Bayer StreamConfiguration when the StreamRole::Raw is requested on a camera configured with raw_frames. Extend validate() to allow Bayer formats, also set the correct stride and frameSize for single plane Bayer buffers. Sensor properties required for SoftISP integration are also declared in match(). Signed-off-by: Max Bretschneider --- src/libcamera/pipeline/virtual/virtual.cpp | 123 ++++++++++++++++++--- src/libcamera/pipeline/virtual/virtual.h | 3 +- 2 files changed, 109 insertions(+), 17 deletions(-) -- 2.43.0 diff --git a/src/libcamera/pipeline/virtual/virtual.cpp b/src/libcamera/pipeline/virtual/virtual.cpp index 81d2ddda..beec2f5a 100644 --- a/src/libcamera/pipeline/virtual/virtual.cpp +++ b/src/libcamera/pipeline/virtual/virtual.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -37,7 +38,6 @@ #include "libcamera/internal/framebuffer.h" #include "libcamera/internal/pipeline_handler.h" #include "libcamera/internal/request.h" -#include "libcamera/internal/value_node.h" #include "pipeline/virtual/config_parser.h" @@ -202,21 +202,28 @@ CameraConfiguration::Status VirtualCameraConfiguration::validate() adjusted = true; } - if (cfg.pixelFormat != formats::NV12) { - cfg.pixelFormat = formats::NV12; - status = Adjusted; - adjusted = true; - } + const PixelFormatInfo &fmtInfo = PixelFormatInfo::info(cfg.pixelFormat); + const bool rawStream = fmtInfo.colourEncoding == PixelFormatInfo::ColourEncodingRAW; - if (cfg.colorSpace != ColorSpace::Rec709) { - cfg.colorSpace = ColorSpace::Rec709; - status = Adjusted; - adjusted = true; - } + if (!rawStream) { + if (cfg.pixelFormat != formats::NV12) { + cfg.pixelFormat = formats::NV12; + status = Adjusted; + adjusted = true; + } - if (validateColorSpaces() == Adjusted) { - status = Adjusted; - adjusted = true; + if (cfg.colorSpace != ColorSpace::Rec709) { + cfg.colorSpace = ColorSpace::Rec709; + status = Adjusted; + adjusted = true; + } + + if (validateColorSpaces() == Adjusted) { + status = Adjusted; + adjusted = true; + } + } else { + cfg.colorSpace = ColorSpace::Raw; } if (adjusted) @@ -267,7 +274,64 @@ PipelineHandlerVirtual::generateConfiguration(Camera *camera, case StreamRole::Viewfinder: break; - case StreamRole::Raw: + case StreamRole::Raw: { + if (!std::holds_alternative(data->config_.frame)) { + LOG(Virtual, Error) + << "StreamRole::Raw requested but camera is not configured with raw_frames"; + return {}; + } + + const auto &rawFrames = std::get(data->config_.frame); + PixelFormat rawFormat; + + /* + * \todo Possibly replace with a lookup table to + * be able to just index by (cfaPatter, bitDepth), + * might be cleaner. + */ + auto bayerFormat = [&](PixelFormat f8, PixelFormat f10, + PixelFormat f12, PixelFormat f14, + PixelFormat f16) { + switch (rawFrames.bitDepth) { + case 8: + return f8; + case 10: + return f10; + case 12: + return f12; + case 14: + return f14; + default: + return f16; + } + }; + + /* Map bayer order and bit depth to pixel format */ + if (rawFrames.cfaPattern == properties::draft::ColorFilterArrangementEnum::RGGB) + rawFormat = bayerFormat(formats::SRGGB8, formats::SRGGB10, formats::SRGGB12, formats::SRGGB14, formats::SRGGB16); + else if (rawFrames.cfaPattern == properties::draft::ColorFilterArrangementEnum::BGGR) + rawFormat = bayerFormat(formats::SBGGR8, formats::SBGGR10, formats::SBGGR12, formats::SBGGR14, formats::SBGGR16); + else if (rawFrames.cfaPattern == properties::draft::ColorFilterArrangementEnum::GRBG) + rawFormat = bayerFormat(formats::SGRBG8, formats::SGRBG10, formats::SGRBG12, formats::SGRBG14, formats::SGRBG16); + else + rawFormat = bayerFormat(formats::SGBRG8, formats::SGBRG10, formats::SGBRG12, formats::SGBRG14, formats::SGBRG16); + + /* + * Use the Bayer format matching the raw frame + * configuration. + */ + std::map> rawStreamFormats; + rawStreamFormats[rawFormat] = { { data->config_.minResolutionSize, data->config_.maxResolutionSize } }; + StreamFormats rawFormats(rawStreamFormats); + StreamConfiguration rawCfg(rawFormats); + rawCfg.pixelFormat = rawFormat; + rawCfg.size = data->config_.maxResolutionSize; + rawCfg.bufferCount = VirtualCameraConfiguration::kBufferCount; + rawCfg.colorSpace = ColorSpace::Raw; + config->addConfiguration(rawCfg); + continue; + } + default: LOG(Virtual, Error) << "Requested stream role not supported: " << role; @@ -401,6 +465,28 @@ bool PipelineHandlerVirtual::match([[maybe_unused]] DeviceEnumerator *enumerator std::set streams; for (auto &streamConfig : data->streamConfigs_) streams.insert(&streamConfig.stream); + + /* Add sensor properties and controls required by SoftISP for raw streams */ + if (std::holds_alternative(data->config_.frame)) { + const auto &rawFrames = std::get(data->config_.frame); + data->properties_.set(properties::draft::ColorFilterArrangement, static_cast(rawFrames.cfaPattern)); + data->properties_.set(properties::PixelArraySize, data->config_.maxResolutionSize); + data->properties_.set(properties::UnitCellSize, Size(1000, 1000)); + + /* Extends existing controlInfo_ with SoftISP required controls */ + ControlInfoMap::Map controls; + for (const auto &[id, info] : data->controlInfo_) + controls[id] = info; + + /* \todo Allow configuration via YAML */ + controls[&controls::AnalogueGain] = ControlInfo(1.0f, 16.0f, 1.0f); + controls[&controls::ExposureTime] = ControlInfo(100, 33333, 10000); + controls[&controls::AeEnable] = ControlInfo(false, true, true); + controls[&controls::AwbEnable] = ControlInfo(false, true, true); + + data->controlInfo_ = ControlInfoMap(std::move(controls), controls::controls); + } + std::string id = data->config_.id; std::shared_ptr camera = Camera::create(std::move(data), id, streams); @@ -434,7 +520,12 @@ bool PipelineHandlerVirtual::initFrameGenerator(Camera *camera) [&](ImageFrames &imageFrames) { for (auto &streamConfig : data->streamConfigs_) streamConfig.frameGenerator = ImageFrameGenerator::create(imageFrames); - } }, + }, + [&](RawFrames &rawFrames) { + for (auto &streamConfig : data->streamConfigs_) + streamConfig.frameGenerator = RawFrameGenerator::create(rawFrames); + }, + }, frame); for (auto &streamConfig : data->streamConfigs_) diff --git a/src/libcamera/pipeline/virtual/virtual.h b/src/libcamera/pipeline/virtual/virtual.h index 215e56fa..48392808 100644 --- a/src/libcamera/pipeline/virtual/virtual.h +++ b/src/libcamera/pipeline/virtual/virtual.h @@ -23,11 +23,12 @@ #include "frame_generator.h" #include "image_frame_generator.h" +#include "raw_frame_generator.h" #include "test_pattern_generator.h" namespace libcamera { -using VirtualFrame = std::variant; +using VirtualFrame = std::variant; class VirtualCameraData : public Camera::Private, public Thread,