[RFC,v2,01/26] libcamera: software_isp: Rename Bayer classes to SoftwareIspInstance
diff mbox series

Message ID 20261118095735.170587-2-bryan.odonoghue@linaro.org
State New
Headers show
Series
  • gpuisp multipass + fixes
Related show

Commit Message

Bryan O'Donoghue Nov. 18, 2026, 9:57 a.m. UTC
The GPUISP multi-pass really wants to run a series of shaders inside of its
process() block. Looking at the classes we have now the Debayer class
really implements high level logic for the ISP that just so happens to be
centered around Bayer operations.

We have already done alot of work to make softisp mesa/thread safe so the
logical step to take is to start adding in support for more shaders to our
existing EGL implementation. It feels lazy sticking to the debayer_->
object and naming convention and moreover it won't be accurate in later
patches.

Its a little less satisfying for the DebayerCpu to rename it to
SoftwareIspInstanceCpu but it also isn't a lie. SoftIsp itself doesn't
especially need to know what is happening inside of the
invokeMethod(process) signal save that "sutff" happens and data is
returned.

For obvious reasons we started with a base class of type Debayer but, now
that we are expanding the capabilities of SoftIsp to go beyond things that
happen in the demosiac phase - we also need to outgrow the constraining
name Bayer - no disrespect to Bruce Bayer himself intended.

Signed-off-by: Bryan O'Donoghue <bryan.odonoghue@linaro.org>
---
 .../internal/software_isp/software_isp.h      |   4 +-
 src/libcamera/software_isp/meson.build        |   6 +-
 src/libcamera/software_isp/software_isp.cpp   |  58 ++---
 ...{debayer.cpp => software_isp_instance.cpp} |  88 ++++----
 .../{debayer.h => software_isp_instance.h}    |   8 +-
 ..._cpu.cpp => software_isp_instance_cpu.cpp} | 200 +++++++++---------
 ...ayer_cpu.h => software_isp_instance_cpu.h} |  16 +-
 ..._egl.cpp => software_isp_instance_gpu.cpp} | 102 ++++-----
 ...ayer_egl.h => software_isp_instance_gpu.h} |   8 +-
 9 files changed, 245 insertions(+), 245 deletions(-)
 rename src/libcamera/software_isp/{debayer.cpp => software_isp_instance.cpp} (72%)
 rename src/libcamera/software_isp/{debayer.h => software_isp_instance.h} (93%)
 rename src/libcamera/software_isp/{debayer_cpu.cpp => software_isp_instance_cpu.cpp} (81%)
 rename src/libcamera/software_isp/{debayer_cpu.h => software_isp_instance_cpu.h} (93%)
 rename src/libcamera/software_isp/{debayer_egl.cpp => software_isp_instance_gpu.cpp} (83%)
 rename src/libcamera/software_isp/{debayer_egl.h => software_isp_instance_gpu.h} (94%)

Patch
diff mbox series

diff --git a/include/libcamera/internal/software_isp/software_isp.h b/include/libcamera/internal/software_isp/software_isp.h
index b64910637..3a2bd556e 100644
--- a/include/libcamera/internal/software_isp/software_isp.h
+++ b/include/libcamera/internal/software_isp/software_isp.h
@@ -36,7 +36,7 @@ 
 
 namespace libcamera {
 
-class Debayer;
+class SoftwareIspInstance;
 class FrameBuffer;
 class PixelFormat;
 class Stream;
@@ -95,7 +95,7 @@  private:
 	void statsReady(uint32_t frame, uint32_t bufferId);
 	void inputReady(FrameBuffer *input);
 	void outputReady(FrameBuffer *output);
-	std::unique_ptr<Debayer> debayer_;
+	std::unique_ptr<SoftwareIspInstance> isp_;
 	Thread ispWorkerThread_;
 	SharedMemObject<DebayerParams> sharedParams_;
 	DebayerParams debayerParams_;
diff --git a/src/libcamera/software_isp/meson.build b/src/libcamera/software_isp/meson.build
index 15f9e4032..f241e4489 100644
--- a/src/libcamera/software_isp/meson.build
+++ b/src/libcamera/software_isp/meson.build
@@ -21,8 +21,8 @@  summary({'SoftISP GPU acceleration' : mesa_works},
 
 libcamera_internal_sources += files([
     'benchmark.cpp',
-    'debayer.cpp',
-    'debayer_cpu.cpp',
+    'software_isp_instance.cpp',
+    'software_isp_instance_cpu.cpp',
     'software_isp.cpp',
     'swstats_cpu.cpp',
 ])
@@ -31,7 +31,7 @@  if mesa_works
     config_h.set('HAVE_DEBAYER_EGL', 1)
     libcamera_internal_sources += files([
         '../egl.cpp',
-        'debayer_egl.cpp',
+        'software_isp_instance_gpu.cpp',
     ])
     libcamera_deps += [
         libegl,
diff --git a/src/libcamera/software_isp/software_isp.cpp b/src/libcamera/software_isp/software_isp.cpp
index 627625b4f..e07f18ff8 100644
--- a/src/libcamera/software_isp/software_isp.cpp
+++ b/src/libcamera/software_isp/software_isp.cpp
@@ -27,9 +27,9 @@ 
 #include "libcamera/internal/framebuffer.h"
 #include "libcamera/internal/software_isp/debayer_params.h"
 
-#include "debayer_cpu.h"
+#include "software_isp_instance_cpu.h"
 #if HAVE_DEBAYER_EGL
-#include "debayer_egl.h"
+#include "software_isp_instance_gpu.h"
 #endif
 
 /**
@@ -121,7 +121,7 @@  SoftwareIsp::SoftwareIsp(PipelineHandler *pipe, const CameraSensor *sensor,
 	if (!softISPMode || softISPMode == "gpu") {
 		auto display = eGL::probeDisplay();
 		if (display != EGL_NO_DISPLAY) {
-			debayer_ = std::make_unique<DebayerEGL>(std::move(stats), cm, display);
+			isp_ = std::make_unique<SoftwareIspInstanceGpu>(std::move(stats), cm, display);
 		} else {
 			LOG(SoftwareIsp, Info)
 				<< "EGL not available, falling back to CPU debayer";
@@ -129,17 +129,17 @@  SoftwareIsp::SoftwareIsp(PipelineHandler *pipe, const CameraSensor *sensor,
 	}
 
 #endif
-	if (!debayer_)
-		debayer_ = std::make_unique<DebayerCpu>(std::move(stats), cm);
+	if (!isp_)
+		isp_ = std::make_unique<SoftwareIspInstanceCpu>(std::move(stats), cm);
 
-	debayer_->inputBufferReady.connect(this, &SoftwareIsp::inputReady);
-	debayer_->outputBufferReady.connect(this, &SoftwareIsp::outputReady);
+	isp_->inputBufferReady.connect(this, &SoftwareIsp::inputReady);
+	isp_->outputBufferReady.connect(this, &SoftwareIsp::outputReady);
 
 	ipa_ = pipe->createIPA<ipa::softisp::IPAProxySoftIsp>(0, 0);
 	if (!ipa_) {
 		LOG(SoftwareIsp, Error)
 			<< "Creating IPA for software ISP failed";
-		debayer_.reset();
+		isp_.reset();
 		return;
 	}
 
@@ -158,7 +158,7 @@  SoftwareIsp::SoftwareIsp(PipelineHandler *pipe, const CameraSensor *sensor,
 	}
 
 	ret = ipa_->init(IPASettings{ ipaTuningFile, sensor->model() },
-			 debayer_->getStatsFD(),
+			 isp_->getStatsFD(),
 			 sharedParams_.fd(),
 			 sensorInfo,
 			 sensor->controls(),
@@ -167,7 +167,7 @@  SoftwareIsp::SoftwareIsp(PipelineHandler *pipe, const CameraSensor *sensor,
 			 &lscEnabled_);
 	if (ret) {
 		LOG(SoftwareIsp, Error) << "IPA init failed";
-		debayer_.reset();
+		isp_.reset();
 		return;
 	}
 
@@ -178,13 +178,13 @@  SoftwareIsp::SoftwareIsp(PipelineHandler *pipe, const CameraSensor *sensor,
 				    });
 	ipa_->setSensorControls.connect(this, &SoftwareIsp::setSensorCtrls);
 
-	debayer_->moveToThread(&ispWorkerThread_);
+	isp_->moveToThread(&ispWorkerThread_);
 }
 
 SoftwareIsp::~SoftwareIsp()
 {
-	/* make sure to destroy the DebayerCpu before the ispWorkerThread_ is gone */
-	debayer_.reset();
+	/* make sure to destroy the SoftwareIspInstanceCpu before the ispWorkerThread_ is gone */
+	isp_.reset();
 }
 
 /**
@@ -219,7 +219,7 @@  void SoftwareIsp::processStats(const uint32_t frame, const uint32_t bufferId,
  */
 bool SoftwareIsp::isValid() const
 {
-	return !!debayer_;
+	return !!isp_;
 }
 
 /**
@@ -229,9 +229,9 @@  bool SoftwareIsp::isValid() const
   */
 std::vector<PixelFormat> SoftwareIsp::formats(PixelFormat inputFormat)
 {
-	ASSERT(debayer_);
+	ASSERT(isp_);
 
-	return debayer_->formats(inputFormat);
+	return isp_->formats(inputFormat);
 }
 
 /**
@@ -242,9 +242,9 @@  std::vector<PixelFormat> SoftwareIsp::formats(PixelFormat inputFormat)
  */
 SizeRange SoftwareIsp::sizes(PixelFormat inputFormat, const Size &inputSize)
 {
-	ASSERT(debayer_);
+	ASSERT(isp_);
 
-	return debayer_->sizes(inputFormat, inputSize);
+	return isp_->sizes(inputFormat, inputSize);
 }
 
 /**
@@ -257,9 +257,9 @@  SizeRange SoftwareIsp::sizes(PixelFormat inputFormat, const Size &inputSize)
 std::tuple<unsigned int, unsigned int>
 SoftwareIsp::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
 {
-	ASSERT(debayer_);
+	ASSERT(isp_);
 
-	return debayer_->strideAndFrameSize(outputFormat, size);
+	return isp_->strideAndFrameSize(outputFormat, size);
 }
 
 /**
@@ -270,9 +270,9 @@  SoftwareIsp::strideAndFrameSize(const PixelFormat &outputFormat, const Size &siz
  */
 uint32_t SoftwareIsp::preferredInputStride(const PixelFormat &inputFormat, const Size &size)
 {
-	ASSERT(debayer_);
+	ASSERT(isp_);
 
-	return debayer_->preferredInputStride(inputFormat, size);
+	return isp_->preferredInputStride(inputFormat, size);
 }
 
 /**
@@ -288,13 +288,13 @@  int SoftwareIsp::configure(const StreamConfiguration &inputCfg,
 			   const ipa::softisp::IPAConfigInfo &configInfo,
 			   ControlInfoMap *ipaControls)
 {
-	ASSERT(ipa_ && debayer_);
+	ASSERT(ipa_ && isp_);
 
 	int ret = ipa_->configure(configInfo, ipaControls);
 	if (ret < 0)
 		return ret;
 
-	ret = debayer_->configure(inputCfg, outputCfgs, ccmEnabled_, lscEnabled_);
+	ret = isp_->configure(inputCfg, outputCfgs, ccmEnabled_, lscEnabled_);
 	if (ret < 0)
 		return ret;
 
@@ -317,13 +317,13 @@  int SoftwareIsp::configure(const StreamConfiguration &inputCfg,
 int SoftwareIsp::exportBuffers(const Stream *stream, unsigned int count,
 			       std::vector<std::unique_ptr<FrameBuffer>> *buffers)
 {
-	ASSERT(debayer_ != nullptr);
+	ASSERT(isp_ != nullptr);
 
 	/* single output for now */
 	if (stream == nullptr)
 		return -EINVAL;
 
-	return dmaHeap_.exportBuffers(count, { debayer_->frameSize() }, buffers);
+	return dmaHeap_.exportBuffers(count, { isp_->frameSize() }, buffers);
 }
 
 /**
@@ -385,7 +385,7 @@  int SoftwareIsp::start()
 
 	ispWorkerThread_.start();
 
-	return debayer_->invokeMethod(&Debayer::start,
+	return isp_->invokeMethod(&SoftwareIspInstance::start,
 				      ConnectionTypeBlocking);
 }
 
@@ -402,7 +402,7 @@  void SoftwareIsp::stop()
 	if (!ispWorkerThread_.isRunning())
 		return;
 
-	debayer_->invokeMethod(&Debayer::stop,
+	isp_->invokeMethod(&SoftwareIspInstance::stop,
 			       ConnectionTypeBlocking);
 
 	ispWorkerThread_.exit();
@@ -434,7 +434,7 @@  void SoftwareIsp::stop()
 void SoftwareIsp::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output)
 {
 	ipa_->computeParams(frame);
-	debayer_->invokeMethod(&Debayer::process,
+	isp_->invokeMethod(&SoftwareIspInstance::process,
 			       ConnectionTypeQueued, frame, input, output, debayerParams_);
 }
 
diff --git a/src/libcamera/software_isp/debayer.cpp b/src/libcamera/software_isp/software_isp_instance.cpp
similarity index 72%
rename from src/libcamera/software_isp/debayer.cpp
rename to src/libcamera/software_isp/software_isp_instance.cpp
index 4f6659000..2c4b72d51 100644
--- a/src/libcamera/software_isp/debayer.cpp
+++ b/src/libcamera/software_isp/software_isp_instance.cpp
@@ -9,7 +9,7 @@ 
  * debayer base class
  */
 
-#include "debayer.h"
+#include "software_isp_instance.h"
 
 namespace libcamera {
 
@@ -85,29 +85,29 @@  namespace libcamera {
  */
 
 /**
- * \class Debayer
+ * \class SoftwareIspInstance
  * \brief Base debayering class
  *
  * Base class that provides functions for setting up the debayering process.
  */
 
-LOG_DEFINE_CATEGORY(Debayer)
+LOG_DEFINE_CATEGORY(SoftwareIspInstance)
 
 /**
- * \brief Construct a Debayer object
+ * \brief Construct a SoftwareIspInstance object
  * \param[in] cm The camera manager
  */
-Debayer::Debayer(const CameraManager &cm)
-	: bench_(cm, "Debayer")
+SoftwareIspInstance::SoftwareIspInstance(const CameraManager &cm)
+	: bench_(cm, "SoftwareIspInstance")
 {
 }
 
-Debayer::~Debayer()
+SoftwareIspInstance::~SoftwareIspInstance()
 {
 }
 
 /**
- * \fn int Debayer::configure()
+ * \fn int SoftwareIspInstance::configure()
  * \brief Configure the debayer object according to the passed in parameters
  * \param[in] inputCfg The input configuration
  * \param[in] outputCfgs The output configurations
@@ -118,7 +118,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn Size Debayer::patternSize(PixelFormat inputFormat)
+ * \fn Size SoftwareIspInstance::patternSize(PixelFormat inputFormat)
  * \brief Get the width and height at which the bayer pattern repeats
  * \param[in] inputFormat The input format
  *
@@ -128,7 +128,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn std::vector<PixelFormat> Debayer::formats(PixelFormat inputFormat)
+ * \fn std::vector<PixelFormat> SoftwareIspInstance::formats(PixelFormat inputFormat)
  * \brief Get the supported output formats
  * \param[in] inputFormat The input format
  *
@@ -136,7 +136,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn std::tuple<unsigned int, unsigned int> Debayer::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
+ * \fn std::tuple<unsigned int, unsigned int> SoftwareIspInstance::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
  * \brief Get the stride and the frame size
  * \param[in] outputFormat The output format
  * \param[in] size The output size
@@ -146,7 +146,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn uint32_t Debayer::preferredInputStride(const PixelFormat &inputFormat, const Size &size)
+ * \fn uint32_t SoftwareIspInstance::preferredInputStride(const PixelFormat &inputFormat, const Size &size)
  * Get the preferred input stride in bytes for the given input format and size
  * \param[in] inputFormat The input format
  * \param[in] size The input size (width and height in pixels)
@@ -154,7 +154,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn void Debayer::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, DebayerParams params)
+ * \fn void SoftwareIspInstance::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, DebayerParams params)
  * \brief Process the bayer data into the requested format
  * \param[in] frame The frame number
  * \param[in] input The input buffer
@@ -166,7 +166,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn virtual SizeRange Debayer::sizes(PixelFormat inputFormat, const Size &inputSize)
+ * \fn virtual SizeRange SoftwareIspInstance::sizes(PixelFormat inputFormat, const Size &inputSize)
  * \brief Get the supported output sizes for the given input format and size
  * \param[in] inputFormat The input format
  * \param[in] inputSize The input size
@@ -175,7 +175,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn const SharedFD &Debayer::getStatsFD()
+ * \fn const SharedFD &SoftwareIspInstance::getStatsFD()
  * \brief Get the file descriptor for the statistics
  *
  * This file descriptor provides access to the output statistics buffer
@@ -185,7 +185,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn unsigned int Debayer::frameSize()
+ * \fn unsigned int SoftwareIspInstance::frameSize()
  * \brief Get the output frame size
  *
  * \return The total output frame size in bytes as configured for the
@@ -193,17 +193,17 @@  Debayer::~Debayer()
  */
 
 /**
- * \var Signal<FrameBuffer *> Debayer::inputBufferReady
+ * \var Signal<FrameBuffer *> SoftwareIspInstance::inputBufferReady
  * \brief Signals when the input buffer is ready
  */
 
 /**
- * \var Signal<FrameBuffer *> Debayer::outputBufferReady
+ * \var Signal<FrameBuffer *> SoftwareIspInstance::outputBufferReady
  * \brief Signals when the output buffer is ready
  */
 
 /**
- * \struct Debayer::DebayerInputConfig
+ * \struct SoftwareIspInstance::DebayerInputConfig
  * \brief Structure describing the incoming Bayer parameters
  *
  * The DebayerInputConfig structure defines the characteristics of the raw
@@ -212,37 +212,37 @@  Debayer::~Debayer()
  *  - Memory layout parameters such as stride and bytes per pixel (\ref bpp)
  *  - A list of supported output pixel formats.
  *
- * \var Debayer::DebayerInputConfig::patternSize
+ * \var SoftwareIspInstance::DebayerInputConfig::patternSize
  * Size of the Bayer pattern in pixels. For standard Bayer formats such as
  * BGGR, GRBG, GBRG, and RGGB, this is typically 2×2 pixels.
  *
- * \var Debayer::DebayerInputConfig::bpp
+ * \var SoftwareIspInstance::DebayerInputConfig::bpp
  * Number of bytes used per pixel in memory. This reflects storage size,
  * not precision.
  *
- * \var Debayer::DebayerInputConfig::stride
+ * \var SoftwareIspInstance::DebayerInputConfig::stride
  * Line stride in bytes for the Bayer input frame.
  *
- * \var Debayer::DebayerInputConfig::outputFormats
+ * \var SoftwareIspInstance::DebayerInputConfig::outputFormats
  * List of pixel formats supported as output for this input configuration.
  */
 
 /**
- * \struct Debayer::DebayerOutputConfig
+ * \struct SoftwareIspInstance::DebayerOutputConfig
  * \brief Structure describing the output frame configuration
  *
  * Defines how the output of the debayer process is laid out in memory.
  * It includes per-pixel size, stride, and total frame size.
  *
- * \var Debayer::DebayerOutputConfig::stride
+ * \var SoftwareIspInstance::DebayerOutputConfig::stride
  * Line stride in bytes for the output frame.
  *
- * \var Debayer::DebayerOutputConfig::frameSize
+ * \var SoftwareIspInstance::DebayerOutputConfig::frameSize
  * Total frame size in bytes for the output buffer.
  */
 
 /**
- * \var Debayer::inputConfig_
+ * \var SoftwareIspInstance::inputConfig_
  * \brief Input configuration parameters for the current debayer operation
  *
  * Holds metadata describing the incoming Bayer image layout, including
@@ -251,7 +251,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \var Debayer::outputConfig_
+ * \var SoftwareIspInstance::outputConfig_
  * \brief Output configuration data for the debayered frame
  *
  * Contains bytes per pixel, stride, and total frame size for the
@@ -259,22 +259,22 @@  Debayer::~Debayer()
  */
 
 /**
- * \var Debayer::inputPixelFormat_
+ * \var SoftwareIspInstance::inputPixelFormat_
  * \brief The incoming pixel format
  */
 
 /**
- * \var Debayer::outputPixelFormat_
+ * \var SoftwareIspInstance::outputPixelFormat_
  * \brief The output pixel format
  */
 
 /**
- * \var Debayer::outputSize_
+ * \var SoftwareIspInstance::outputSize_
  * \brief Output size object
  */
 
 /**
- * \var Debayer::swapRedBlueGains_
+ * \var SoftwareIspInstance::swapRedBlueGains_
  * \brief Flag indicating whether red and blue channel gains should be swapped
  *
  * Used when the Bayer pattern order indicates that red/blue color channels are
@@ -282,7 +282,7 @@  Debayer::~Debayer()
  */
 
 /**
- * \var Debayer::bench_
+ * \var SoftwareIspInstance::bench_
  * \brief Benchmarking utility instance for performance measurements
  *
  * Used internally to track timing and performance metrics during
@@ -290,35 +290,35 @@  Debayer::~Debayer()
  */
 
 /**
- * \fn int Debayer::start()
+ * \fn int SoftwareIspInstance::start()
  * \brief Execute a start signal in the debayer object from workerthread context
  *
- * The start() method is invoked so that a Debayer object can initialise
+ * The start() method is invoked so that a SoftwareIspInstance object can initialise
  * internal variables or data. It is called from the software_isp::start
  * method.
  *
- * This method is particularly useful with DebayerEGL as it allows for the
+ * This method is particularly useful with SoftwareIspInstanceGpu as it allows for the
  * initialisation of the EGL stack after configure in a thread-safe manner.
  */
 
 /**
- * \fn void Debayer::stop()
+ * \fn void SoftwareIspInstance::stop()
  * \brief Stop the debayering process and perform cleanup
  *
  * The stop() method is invoked as the logically corollary of start().
- * Debayer::stop() will be called by software_isp::stop() allowing for any
+ * SoftwareIspInstance::stop() will be called by software_isp::stop() allowing for any
  * cleanup which should happend with stop().
  *
- * The stop method similar to start() is useful for DebayerEGL as it allows
+ * The stop method similar to start() is useful for SoftwareIspInstanceGpu as it allows
  * for cleanup of EGL context and/or data that happens in
- * DebayerEGL::start.
+ * SoftwareIspInstanceGpu::start.
  */
 
 /**
- * \fn void Debayer::dmaSyncBegin(DebayerParams &params)
+ * \fn void SoftwareIspInstance::dmaSyncBegin(DebayerParams &params)
  * \brief Common CPU/GPU Dma Sync Buffer begin
  */
-void Debayer::dmaSyncBegin(std::vector<DmaSyncer> &dmaSyncers, FrameBuffer *input, FrameBuffer *output)
+void SoftwareIspInstance::dmaSyncBegin(std::vector<DmaSyncer> &dmaSyncers, FrameBuffer *input, FrameBuffer *output)
 {
 	for (const FrameBuffer::Plane &plane : input->planes())
 		dmaSyncers.emplace_back(plane.fd, DmaSyncer::SyncType::Read);
@@ -330,10 +330,10 @@  void Debayer::dmaSyncBegin(std::vector<DmaSyncer> &dmaSyncers, FrameBuffer *inpu
 }
 
 /**
- * \fn void Debayer::isStandardBayerOrder(BayerFormat::Order order)
+ * \fn void SoftwareIspInstance::isStandardBayerOrder(BayerFormat::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 SoftwareIspInstance::isStandardBayerOrder(BayerFormat::Order order)
 {
 	return order == BayerFormat::BGGR || order == BayerFormat::GBRG ||
 	       order == BayerFormat::GRBG || order == BayerFormat::RGGB;
diff --git a/src/libcamera/software_isp/debayer.h b/src/libcamera/software_isp/software_isp_instance.h
similarity index 93%
rename from src/libcamera/software_isp/debayer.h
rename to src/libcamera/software_isp/software_isp_instance.h
index e30a05279..56728b111 100644
--- a/src/libcamera/software_isp/debayer.h
+++ b/src/libcamera/software_isp/software_isp_instance.h
@@ -30,13 +30,13 @@  namespace libcamera {
 class CameraManager;
 class FrameBuffer;
 
-LOG_DECLARE_CATEGORY(Debayer)
+LOG_DECLARE_CATEGORY(SoftwareIspInstance)
 
-class Debayer : public Object
+class SoftwareIspInstance : public Object
 {
 public:
-	Debayer(const CameraManager &cm);
-	virtual ~Debayer() = 0;
+	SoftwareIspInstance(const CameraManager &cm);
+	virtual ~SoftwareIspInstance() = 0;
 
 	virtual int configure(const StreamConfiguration &inputCfg,
 			      const std::vector<std::reference_wrapper<const StreamConfiguration>> &outputCfgs,
diff --git a/src/libcamera/software_isp/debayer_cpu.cpp b/src/libcamera/software_isp/software_isp_instance_cpu.cpp
similarity index 81%
rename from src/libcamera/software_isp/debayer_cpu.cpp
rename to src/libcamera/software_isp/software_isp_instance_cpu.cpp
index 91867baa6..2d71d11d4 100644
--- a/src/libcamera/software_isp/debayer_cpu.cpp
+++ b/src/libcamera/software_isp/software_isp_instance_cpu.cpp
@@ -9,7 +9,7 @@ 
  * CPU based debayering class
  */
 
-#include "debayer_cpu.h"
+#include "software_isp_instance_cpu.h"
 
 #include <algorithm>
 #include <stdlib.h>
@@ -36,10 +36,10 @@  namespace libcamera {
  *
  * Implementation for CPU based debayering threads.
  */
-class DebayerCpuThread : public Thread, public Object
+class SoftwareIspInstanceCpuThread : public Thread, public Object
 {
 public:
-	DebayerCpuThread(DebayerCpu *debayer, unsigned int threadIndex,
+	SoftwareIspInstanceCpuThread(SoftwareIspInstanceCpu *isp, unsigned int threadIndex,
 			 bool enableInputMemcpy);
 
 	void configure(unsigned int yStart, unsigned int yEnd);
@@ -55,7 +55,7 @@  private:
 	/* Max. supported Bayer pattern height is 4, debayering this requires 5 lines */
 	static constexpr unsigned int kMaxLineBuffers = 5;
 
-	DebayerCpu *debayer_;
+	SoftwareIspInstanceCpu *isp_;
 	unsigned int threadIndex_;
 	unsigned int yStart_;
 	unsigned int yEnd_;
@@ -67,34 +67,34 @@  private:
 };
 
 /**
- * \brief Construct a DebayerCpuThread object
- * \param[in] debayer pointer back to the DebayerCpuObject this thread belongs to
+ * \brief Construct a SoftwareIspInstanceCpuThread object
+ * \param[in] isp pointer back to the DebayerCpuObject this thread belongs to
  * \param[in] threadIndex 0 .. n thread-index value for the thread
  * \param[in] enableInputMemcpy when set copy input data to a heap buffer before use
  */
-DebayerCpuThread::DebayerCpuThread(DebayerCpu *debayer, unsigned int threadIndex,
+SoftwareIspInstanceCpuThread::SoftwareIspInstanceCpuThread(SoftwareIspInstanceCpu *isp, unsigned int threadIndex,
 				   bool enableInputMemcpy)
-	: Thread("DebayerCpu:" + std::to_string(threadIndex)),
-	  debayer_(debayer), threadIndex_(threadIndex),
+	: Thread("SoftwareIspInstanceCpu:" + std::to_string(threadIndex)),
+	  isp_(isp), threadIndex_(threadIndex),
 	  enableInputMemcpy_(enableInputMemcpy)
 {
 	moveToThread(this);
 }
 
 /**
- * \class DebayerCpu
+ * \class SoftwareIspInstanceCpu
  * \brief Class for debayering on the CPU
  *
  * Implementation for CPU based debayering
  */
 
 /**
- * \brief Constructs a DebayerCpu object
+ * \brief Constructs a SoftwareIspInstanceCpu object
  * \param[in] stats Pointer to the stats object to use
  * \param[in] cm The camera manager
  */
-DebayerCpu::DebayerCpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm)
-	: Debayer(cm), stats_(std::move(stats))
+SoftwareIspInstanceCpu::SoftwareIspInstanceCpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm)
+	: SoftwareIspInstance(cm), stats_(std::move(stats))
 {
 	/*
 	 * Reading from uncached buffers may be very slow.
@@ -117,12 +117,12 @@  DebayerCpu::DebayerCpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &c
 	threads_.resize(threadCount);
 
 	for (unsigned int i = 0; i < threads_.size(); i++)
-		threads_[i] = std::make_unique<DebayerCpuThread>(this, i, enableInputMemcpy);
+		threads_[i] = std::make_unique<SoftwareIspInstanceCpuThread>(this, i, enableInputMemcpy);
 
-	LOG(Debayer, Debug) << "Thread count " << threadCount;
+	LOG(SoftwareIspInstance, Debug) << "Thread count " << threadCount;
 }
 
-DebayerCpu::~DebayerCpu() = default;
+SoftwareIspInstanceCpu::~SoftwareIspInstanceCpu() = default;
 
 #define DECLARE_SRC_POINTERS(pixel_t)                            \
 	const pixel_t *prev = (const pixel_t *)src[0] + xShift_; \
@@ -194,7 +194,7 @@  DebayerCpu::~DebayerCpu() = default;
 		curr[x] / (div))
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer8_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer8_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint8_t)
 
@@ -205,7 +205,7 @@  void DebayerCpu::debayer8_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer8_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer8_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint8_t)
 
@@ -216,7 +216,7 @@  void DebayerCpu::debayer8_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint16_t)
 
@@ -228,7 +228,7 @@  void DebayerCpu::debayer10_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint16_t)
 
@@ -240,7 +240,7 @@  void DebayerCpu::debayer10_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint16_t)
 
@@ -252,7 +252,7 @@  void DebayerCpu::debayer12_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	DECLARE_SRC_POINTERS(uint16_t)
 
@@ -264,7 +264,7 @@  void DebayerCpu::debayer12_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 5 / 4;
 	const uint8_t *prev = src[0];
@@ -290,7 +290,7 @@  void DebayerCpu::debayer10P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 5 / 4;
 	const uint8_t *prev = src[0];
@@ -311,7 +311,7 @@  void DebayerCpu::debayer10P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 5 / 4;
 	const uint8_t *prev = src[0];
@@ -332,7 +332,7 @@  void DebayerCpu::debayer10P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer10P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer10P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 5 / 4;
 	const uint8_t *prev = src[0];
@@ -353,7 +353,7 @@  void DebayerCpu::debayer10P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 3 / 2;
 	const uint8_t *prev = src[0];
@@ -371,7 +371,7 @@  void DebayerCpu::debayer12P_BGBG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 3 / 2;
 	const uint8_t *prev = src[0];
@@ -389,7 +389,7 @@  void DebayerCpu::debayer12P_GRGR_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 3 / 2;
 	const uint8_t *prev = src[0];
@@ -407,7 +407,7 @@  void DebayerCpu::debayer12P_GBGB_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 template<bool addAlphaByte, bool ccmEnabled>
-void DebayerCpu::debayer12P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
+void SoftwareIspInstanceCpu::debayer12P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
 {
 	const int widthInBytes = window_.width * 3 / 2;
 	const uint8_t *prev = src[0];
@@ -425,11 +425,11 @@  void DebayerCpu::debayer12P_RGRG_BGR888(uint8_t *dst, const uint8_t *src[])
 }
 
 /*
- * Setup the Debayer object according to the passed in parameters.
+ * Setup the SoftwareIspInstance object according to the passed in parameters.
  * Return 0 on success, a negative errno value on failure
  * (unsupported parameters).
  */
-int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config)
+int SoftwareIspInstanceCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config)
 {
 	BayerFormat bayerFormat =
 		BayerFormat::fromPixelFormat(inputFormat);
@@ -470,7 +470,7 @@  int DebayerCpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf
 		return 0;
 	}
 
-	LOG(Debayer, Debug)
+	LOG(SoftwareIspInstance, Debug)
 		<< "Unsupported input format " << inputFormat;
 	return -EINVAL;
 }
@@ -479,7 +479,7 @@  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 SoftwareIspInstanceCpu::setupStandardBayerOrder(BayerFormat::Order order)
 {
 	switch (order) {
 	case BayerFormat::BGGR:
@@ -503,13 +503,13 @@  int DebayerCpu::setupStandardBayerOrder(BayerFormat::Order order)
 
 #define SET_DEBAYER_METHODS(method0, method1)                                                                        \
 	debayer0_ = addAlphaByte                                                                                     \
-			    ? (ccmEnabled ? &DebayerCpu::method0<true, true> : &DebayerCpu::method0<true, false>)    \
-			    : (ccmEnabled ? &DebayerCpu::method0<false, true> : &DebayerCpu::method0<false, false>); \
+			    ? (ccmEnabled ? &SoftwareIspInstanceCpu::method0<true, true> : &SoftwareIspInstanceCpu::method0<true, false>)    \
+			    : (ccmEnabled ? &SoftwareIspInstanceCpu::method0<false, true> : &SoftwareIspInstanceCpu::method0<false, false>); \
 	debayer1_ = addAlphaByte                                                                                     \
-			    ? (ccmEnabled ? &DebayerCpu::method1<true, true> : &DebayerCpu::method1<true, false>)    \
-			    : (ccmEnabled ? &DebayerCpu::method1<false, true> : &DebayerCpu::method1<false, false>);
+			    ? (ccmEnabled ? &SoftwareIspInstanceCpu::method1<true, true> : &SoftwareIspInstanceCpu::method1<true, false>)    \
+			    : (ccmEnabled ? &SoftwareIspInstanceCpu::method1<false, true> : &SoftwareIspInstanceCpu::method1<false, false>);
 
-int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat,
+int SoftwareIspInstanceCpu::setDebayerFunctions(PixelFormat inputFormat,
 				    PixelFormat outputFormat,
 				    bool ccmEnabled)
 {
@@ -521,7 +521,7 @@  int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat,
 	swapRedBlueGains_ = false;
 
 	auto invalidFmt = []() -> int {
-		LOG(Debayer, Error) << "Unsupported input output format combination";
+		LOG(SoftwareIspInstance, Error) << "Unsupported input output format combination";
 		return -EINVAL;
 	};
 
@@ -622,13 +622,13 @@  int DebayerCpu::setDebayerFunctions(PixelFormat inputFormat,
 	return invalidFmt();
 }
 
-int DebayerCpu::configure(const StreamConfiguration &inputCfg,
+int SoftwareIspInstanceCpu::configure(const StreamConfiguration &inputCfg,
 			  const std::vector<std::reference_wrapper<const StreamConfiguration>> &outputCfgs,
 			  bool ccmEnabled,
 			  [[maybe_unused]] bool lscEnabled)
 {
 	if (getInputConfig(inputCfg.pixelFormat, inputConfig_) != 0) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Unsupported input format " << inputCfg.pixelFormat;
 		return -EINVAL;
 	}
@@ -639,7 +639,7 @@  int DebayerCpu::configure(const StreamConfiguration &inputCfg,
 	const Size &statsPatternSize = stats_->patternSize();
 	if (inputConfig_.patternSize.width != statsPatternSize.width ||
 	    inputConfig_.patternSize.height != statsPatternSize.height) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "mismatching stats and debayer pattern sizes for "
 			<< inputCfg.pixelFormat.toString();
 		return -EINVAL;
@@ -648,7 +648,7 @@  int DebayerCpu::configure(const StreamConfiguration &inputCfg,
 	inputConfig_.stride = inputCfg.stride;
 
 	if (outputCfgs.size() != 1) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Unsupported number of output streams: "
 			<< outputCfgs.size();
 		return -EINVAL;
@@ -660,7 +660,7 @@  int DebayerCpu::configure(const StreamConfiguration &inputCfg,
 		strideAndFrameSize(outputCfg.pixelFormat, outputCfg.size);
 
 	if (!outSizeRange.contains(outputCfg.size) || outputConfig_.stride != outputCfg.stride) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Invalid output size/stride: "
 			<< "\n  " << outputCfg.size << " (" << outSizeRange << ")"
 			<< "\n  " << outputCfg.stride << " (" << outputConfig_.stride << ")";
@@ -718,16 +718,16 @@  int DebayerCpu::configure(const StreamConfiguration &inputCfg,
  *
  * Configure the thread to process lines from yStart to yEnd - 1.
  */
-void DebayerCpuThread::configure(unsigned int yStart, unsigned int yEnd)
+void SoftwareIspInstanceCpuThread::configure(unsigned int yStart, unsigned int yEnd)
 {
-	Debayer::DebayerInputConfig &inputConfig = debayer_->inputConfig_;
+	SoftwareIspInstance::DebayerInputConfig &inputConfig = isp_->inputConfig_;
 
 	yStart_ = yStart;
 	yEnd_ = yEnd;
 
 	/* pad with patternSize.Width on both left and right side */
 	lineBufferPadding_ = inputConfig.patternSize.width * inputConfig.bpp / 8;
-	lineBufferLength_ = debayer_->window_.width * inputConfig.bpp / 8 +
+	lineBufferLength_ = isp_->window_.width * inputConfig.bpp / 8 +
 			    2 * lineBufferPadding_;
 
 	if (enableInputMemcpy_) {
@@ -740,9 +740,9 @@  void DebayerCpuThread::configure(unsigned int yStart, unsigned int yEnd)
  * Get width and height at which the bayer-pattern repeats.
  * Return pattern-size or an empty Size for an unsupported inputFormat.
  */
-Size DebayerCpu::patternSize(PixelFormat inputFormat)
+Size SoftwareIspInstanceCpu::patternSize(PixelFormat inputFormat)
 {
-	DebayerCpu::DebayerInputConfig config;
+	SoftwareIspInstanceCpu::DebayerInputConfig config;
 
 	if (getInputConfig(inputFormat, config) != 0)
 		return {};
@@ -750,9 +750,9 @@  Size DebayerCpu::patternSize(PixelFormat inputFormat)
 	return config.patternSize;
 }
 
-std::vector<PixelFormat> DebayerCpu::formats(PixelFormat inputFormat)
+std::vector<PixelFormat> SoftwareIspInstanceCpu::formats(PixelFormat inputFormat)
 {
-	DebayerCpu::DebayerInputConfig config;
+	SoftwareIspInstanceCpu::DebayerInputConfig config;
 
 	if (getInputConfig(inputFormat, config) != 0)
 		return std::vector<PixelFormat>();
@@ -761,16 +761,16 @@  std::vector<PixelFormat> DebayerCpu::formats(PixelFormat inputFormat)
 }
 
 std::tuple<unsigned int, unsigned int>
-DebayerCpu::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
+SoftwareIspInstanceCpu::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
 {
 	/* round up to multiple of 8 for 64 bits alignment */
 	const PixelFormatInfo &info = PixelFormatInfo::info(outputFormat);
 	return std::make_tuple(info.stride(size.width, 0, 8), info.frameSize(size, 8));
 }
 
-void DebayerCpuThread::setupInputMemcpy(const uint8_t *linePointers[])
+void SoftwareIspInstanceCpuThread::setupInputMemcpy(const uint8_t *linePointers[])
 {
-	const unsigned int patternHeight = debayer_->inputConfig_.patternSize.height;
+	const unsigned int patternHeight = isp_->inputConfig_.patternSize.height;
 
 	if (!enableInputMemcpy_)
 		return;
@@ -786,20 +786,20 @@  void DebayerCpuThread::setupInputMemcpy(const uint8_t *linePointers[])
 	lineBufferIndex_ = patternHeight;
 }
 
-void DebayerCpuThread::shiftLinePointers(const uint8_t *linePointers[], const uint8_t *src)
+void SoftwareIspInstanceCpuThread::shiftLinePointers(const uint8_t *linePointers[], const uint8_t *src)
 {
-	const unsigned int patternHeight = debayer_->inputConfig_.patternSize.height;
+	const unsigned int patternHeight = isp_->inputConfig_.patternSize.height;
 
 	for (unsigned int i = 0; i < patternHeight; i++)
 		linePointers[i] = linePointers[i + 1];
 
 	linePointers[patternHeight] =
-		src + (patternHeight / 2) * (int)debayer_->inputConfig_.stride;
+		src + (patternHeight / 2) * (int)isp_->inputConfig_.stride;
 }
 
-void DebayerCpuThread::memcpyNextLine(const uint8_t *linePointers[])
+void SoftwareIspInstanceCpuThread::memcpyNextLine(const uint8_t *linePointers[])
 {
-	const unsigned int patternHeight = debayer_->inputConfig_.patternSize.height;
+	const unsigned int patternHeight = isp_->inputConfig_.patternSize.height;
 
 	if (!enableInputMemcpy_)
 		return;
@@ -818,32 +818,32 @@  void DebayerCpuThread::memcpyNextLine(const uint8_t *linePointers[])
  * \param[in] src The source buffer
  * \param[in] dst The destination buffer
  */
-void DebayerCpuThread::process(uint32_t frame, const uint8_t *src, uint8_t *dst)
+void SoftwareIspInstanceCpuThread::process(uint32_t frame, const uint8_t *src, uint8_t *dst)
 {
-	Rectangle &window = debayer_->window_;
+	Rectangle &window = isp_->window_;
 
 	/* Adjust src to top left corner of the window */
-	src += (window.y + yStart_) * debayer_->inputConfig_.stride +
-	       window.x * debayer_->inputConfig_.bpp / 8;
+	src += (window.y + yStart_) * isp_->inputConfig_.stride +
+	       window.x * isp_->inputConfig_.bpp / 8;
 	/* Adjust dst for yStart_ */
-	dst += yStart_ * debayer_->outputConfig_.stride;
+	dst += yStart_ * isp_->outputConfig_.stride;
 
-	if (debayer_->inputConfig_.patternSize.height == 2)
+	if (isp_->inputConfig_.patternSize.height == 2)
 		process2(frame, src, dst);
 	else
 		process4(frame, src, dst);
 
-	debayer_->workPendingMutex_.lock();
-	debayer_->workPending_ &= ~(1 << threadIndex_);
-	debayer_->workPendingMutex_.unlock();
-	debayer_->workPendingCv_.notify_one();
+	isp_->workPendingMutex_.lock();
+	isp_->workPending_ &= ~(1 << threadIndex_);
+	isp_->workPendingMutex_.unlock();
+	isp_->workPendingCv_.notify_one();
 }
 
-void DebayerCpuThread::process2(uint32_t frame, const uint8_t *src, uint8_t *dst)
+void SoftwareIspInstanceCpuThread::process2(uint32_t frame, const uint8_t *src, uint8_t *dst)
 {
-	unsigned int outputStride = debayer_->outputConfig_.stride;
-	unsigned int inputStride = debayer_->inputConfig_.stride;
-	Rectangle &window = debayer_->window_;
+	unsigned int outputStride = isp_->outputConfig_.stride;
+	unsigned int inputStride = isp_->inputConfig_.stride;
+	Rectangle &window = isp_->window_;
 	unsigned int yEnd = yEnd_;
 	/* Holds [0] previous- [1] current- [2] next-line */
 	const uint8_t *linePointers[3];
@@ -876,14 +876,14 @@  void DebayerCpuThread::process2(uint32_t frame, const uint8_t *src, uint8_t *dst
 	for (unsigned int y = yStart_; y < yEnd; y += 2) {
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->stats_->processLine0(frame, y, linePointers, threadIndex_);
-		debayer_->debayer0(dst, linePointers);
+		isp_->stats_->processLine0(frame, y, linePointers, threadIndex_);
+		isp_->debayer0(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->debayer1(dst, linePointers);
+		isp_->debayer1(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 	}
@@ -891,24 +891,24 @@  void DebayerCpuThread::process2(uint32_t frame, const uint8_t *src, uint8_t *dst
 	if (window.y == 0 && yEnd_ == window.height) {
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->stats_->processLine0(frame, yEnd, linePointers, threadIndex_);
-		debayer_->debayer0(dst, linePointers);
+		isp_->stats_->processLine0(frame, yEnd, linePointers, threadIndex_);
+		isp_->debayer0(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 
 		shiftLinePointers(linePointers, src);
 		/* next line may point outside of src, use prev. */
 		linePointers[2] = linePointers[0];
-		debayer_->debayer1(dst, linePointers);
+		isp_->debayer1(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 	}
 }
 
-void DebayerCpuThread::process4(uint32_t frame, const uint8_t *src, uint8_t *dst)
+void SoftwareIspInstanceCpuThread::process4(uint32_t frame, const uint8_t *src, uint8_t *dst)
 {
-	unsigned int outputStride = debayer_->outputConfig_.stride;
-	unsigned int inputStride = debayer_->inputConfig_.stride;
+	unsigned int outputStride = isp_->outputConfig_.stride;
+	unsigned int inputStride = isp_->inputConfig_.stride;
 
 	/*
 	 * This holds pointers to [0] 2-lines-up [1] 1-line-up [2] current-line
@@ -932,33 +932,33 @@  void DebayerCpuThread::process4(uint32_t frame, const uint8_t *src, uint8_t *dst
 	for (unsigned int y = yStart_; y < yEnd_; y += 4) {
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->stats_->processLine0(frame, y, linePointers, threadIndex_);
-		debayer_->debayer0(dst, linePointers);
+		isp_->stats_->processLine0(frame, y, linePointers, threadIndex_);
+		isp_->debayer0(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->debayer1(dst, linePointers);
+		isp_->debayer1(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->stats_->processLine2(frame, y, linePointers, threadIndex_);
-		debayer_->debayer2(dst, linePointers);
+		isp_->stats_->processLine2(frame, y, linePointers, threadIndex_);
+		isp_->debayer2(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 
 		shiftLinePointers(linePointers, src);
 		memcpyNextLine(linePointers);
-		debayer_->debayer3(dst, linePointers);
+		isp_->debayer3(dst, linePointers);
 		src += inputStride;
 		dst += outputStride;
 	}
 }
 
-void DebayerCpu::updateGammaTable(const DebayerParams &params)
+void SoftwareIspInstanceCpu::updateGammaTable(const DebayerParams &params)
 {
 	const float gamma = params.gamma;
 	const float contrastExp = params.contrastExp;
@@ -976,7 +976,7 @@  void DebayerCpu::updateGammaTable(const DebayerParams &params)
 	}
 }
 
-void DebayerCpu::updateLookupTables(const DebayerParams &params)
+void SoftwareIspInstanceCpu::updateLookupTables(const DebayerParams &params)
 {
 	const bool gammaUpdateNeeded =
 		params.gamma != params_.gamma ||
@@ -1036,8 +1036,8 @@  void DebayerCpu::updateLookupTables(const DebayerParams &params)
 		}
 	}
 
-	LOG(Debayer, Debug)
-		<< "Debayer parameters: blackLevel=" << params.blackLevel
+	LOG(SoftwareIspInstance, Debug)
+		<< "SoftwareIspInstance parameters: blackLevel=" << params.blackLevel
 		<< "; gamma=" << params.gamma
 		<< "; contrastExp=" << params.contrastExp
 		<< "; gains=" << params.gains
@@ -1046,7 +1046,7 @@  void DebayerCpu::updateLookupTables(const DebayerParams &params)
 	params_ = params;
 }
 
-void DebayerCpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, const DebayerParams &params)
+void SoftwareIspInstanceCpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, const DebayerParams &params)
 {
 	bench_.startFrame();
 
@@ -1065,7 +1065,7 @@  void DebayerCpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output
 	MappedFrameBuffer in(input, MappedFrameBuffer::MapFlag::Read);
 	MappedFrameBuffer out(output, MappedFrameBuffer::MapFlag::Write);
 	if (!in.isValid() || !out.isValid()) {
-		LOG(Debayer, Error) << "mmap-ing buffer(s) failed";
+		LOG(SoftwareIspInstance, Error) << "mmap-ing buffer(s) failed";
 		metadata.status = FrameMetadata::FrameError;
 		return;
 	}
@@ -1077,7 +1077,7 @@  void DebayerCpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output
 	workPendingMutex_.unlock();
 
 	for (auto &thread : threads_)
-		thread->invokeMethod(&DebayerCpuThread::process,
+		thread->invokeMethod(&SoftwareIspInstanceCpuThread::process,
 				     ConnectionTypeQueued, frame,
 				     in.planes()[0].data(), out.planes()[0].data());
 
@@ -1105,7 +1105,7 @@  void DebayerCpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output
 	inputBufferReady.emit(input);
 }
 
-int DebayerCpu::start()
+int SoftwareIspInstanceCpu::start()
 {
 	for (auto &thread : threads_)
 		thread->start();
@@ -1113,7 +1113,7 @@  int DebayerCpu::start()
 	return 0;
 }
 
-void DebayerCpu::stop()
+void SoftwareIspInstanceCpu::stop()
 {
 	for (auto &thread : threads_)
 		thread->exit();
@@ -1122,7 +1122,7 @@  void DebayerCpu::stop()
 		thread->wait();
 }
 
-SizeRange DebayerCpu::sizes(PixelFormat inputFormat, const Size &inputSize)
+SizeRange SoftwareIspInstanceCpu::sizes(PixelFormat inputFormat, const Size &inputSize)
 {
 	Size patternSize = this->patternSize(inputFormat);
 	unsigned int borderHeight = patternSize.height;
@@ -1140,7 +1140,7 @@  SizeRange DebayerCpu::sizes(PixelFormat inputFormat, const Size &inputSize)
 	 */
 	if (inputSize.width < (3 * patternSize.width) ||
 	    inputSize.height < (2 * borderHeight + patternSize.height)) {
-		LOG(Debayer, Warning)
+		LOG(SoftwareIspInstance, Warning)
 			<< "Input format size too small: " << inputSize.toString();
 		return {};
 	}
diff --git a/src/libcamera/software_isp/debayer_cpu.h b/src/libcamera/software_isp/software_isp_instance_cpu.h
similarity index 93%
rename from src/libcamera/software_isp/debayer_cpu.h
rename to src/libcamera/software_isp/software_isp_instance_cpu.h
index ae570893b..01448ab81 100644
--- a/src/libcamera/software_isp/debayer_cpu.h
+++ b/src/libcamera/software_isp/software_isp_instance_cpu.h
@@ -24,16 +24,16 @@ 
 #include "libcamera/internal/software_isp/debayer_params.h"
 #include "libcamera/internal/software_isp/swstats_cpu.h"
 
-#include "debayer.h"
+#include "software_isp_instance.h"
 
 namespace libcamera {
 
-class DebayerCpuThread;
-class DebayerCpu : public Debayer
+class SoftwareIspInstanceCpuThread;
+class SoftwareIspInstanceCpu : public SoftwareIspInstance
 {
 public:
-	DebayerCpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm);
-	~DebayerCpu();
+	SoftwareIspInstanceCpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm);
+	~SoftwareIspInstanceCpu();
 
 	int configure(const StreamConfiguration &inputCfg,
 		      const std::vector<std::reference_wrapper<const StreamConfiguration>> &outputCfgs,
@@ -50,7 +50,7 @@  public:
 	const SharedFD &getStatsFD() override { return stats_->getStatsFD(); }
 
 private:
-	friend class DebayerCpuThread;
+	friend class SoftwareIspInstanceCpuThread;
 
 	/**
 	 * \brief Called to debayer 1 line of Bayer input data to output format
@@ -80,7 +80,7 @@  private:
 	 * pointers are passed holding: src[0] = 2-lines-up, src[1] = 1-line-up
 	 * src[2] = current-line, src[3] = 1-line-down, src[4] = 2-lines-down.
 	 */
-	using debayerFn = void (DebayerCpu::*)(uint8_t *dst, const uint8_t *src[]);
+	using debayerFn = void (SoftwareIspInstanceCpu::*)(uint8_t *dst, const uint8_t *src[]);
 
 	void debayer0(uint8_t *dst, const uint8_t *src[]) { (this->*debayer0_)(dst, src); }
 	void debayer1(uint8_t *dst, const uint8_t *src[]) { (this->*debayer1_)(dst, src); }
@@ -164,7 +164,7 @@  private:
 	unsigned int workPending_ LIBCAMERA_TSA_GUARDED_BY(workPendingMutex_);
 	Mutex workPendingMutex_;
 	ConditionVariable workPendingCv_;
-	std::vector<std::unique_ptr<DebayerCpuThread>> threads_;
+	std::vector<std::unique_ptr<SoftwareIspInstanceCpuThread>> threads_;
 };
 
 } /* namespace libcamera */
diff --git a/src/libcamera/software_isp/debayer_egl.cpp b/src/libcamera/software_isp/software_isp_instance_gpu.cpp
similarity index 83%
rename from src/libcamera/software_isp/debayer_egl.cpp
rename to src/libcamera/software_isp/software_isp_instance_gpu.cpp
index 33933b11d..db6b23144 100644
--- a/src/libcamera/software_isp/debayer_egl.cpp
+++ b/src/libcamera/software_isp/software_isp_instance_gpu.cpp
@@ -7,7 +7,7 @@ 
  *
  */
 
-#include "debayer_egl.h"
+#include "software_isp_instance_gpu.h"
 
 #include <algorithm>
 #include <assert.h>
@@ -30,28 +30,28 @@ 
 namespace libcamera {
 
 /**
- * \class DebayerEGL
+ * \class SoftwareIspInstanceGpu
  * \brief Class for debayering using an EGL Shader
  *
  * Implements an EGL shader based debayering solution.
  */
 
 /**
- * \brief Construct a DebayerEGL object
+ * \brief Construct a SoftwareIspInstanceGpu object
  * \param[in] stats Statistics processing object
  * \param[in] cm The camera manager
  * \param[in] display The EGL display to use
  */
-DebayerEGL::DebayerEGL(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm, EGLDisplay display)
-	: Debayer(cm), stats_(std::move(stats)), egl_(display)
+SoftwareIspInstanceGpu::SoftwareIspInstanceGpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm, EGLDisplay display)
+	: SoftwareIspInstance(cm), stats_(std::move(stats)), egl_(display)
 {
 }
 
-DebayerEGL::~DebayerEGL()
+SoftwareIspInstanceGpu::~SoftwareIspInstanceGpu()
 {
 }
 
-int DebayerEGL::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config)
+int SoftwareIspInstanceGpu::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &config)
 {
 	BayerFormat bayerFormat =
 		BayerFormat::fromPixelFormat(inputFormat);
@@ -91,13 +91,13 @@  int DebayerEGL::getInputConfig(PixelFormat inputFormat, DebayerInputConfig &conf
 		return 0;
 	}
 
-	LOG(Debayer, Debug)
+	LOG(SoftwareIspInstance, Debug)
 		<< "Unsupported input format " << inputFormat;
 
 	return -EINVAL;
 }
 
-int DebayerEGL::getShaderVariableLocations(void)
+int SoftwareIspInstanceGpu::getShaderVariableLocations(void)
 {
 	attributeVertex_ = glGetAttribLocation(programId_, "vertexIn");
 	attributeTexture_ = glGetAttribLocation(programId_, "textureIn");
@@ -117,7 +117,7 @@  int DebayerEGL::getShaderVariableLocations(void)
 
 	textureUniformLsc_ = glGetUniformLocation(programId_, "lsc_tex");
 
-	LOG(Debayer, Debug) << "vertexIn " << attributeVertex_ << " textureIn " << attributeTexture_
+	LOG(SoftwareIspInstance, Debug) << "vertexIn " << attributeVertex_ << " textureIn " << attributeTexture_
 			    << " tex_y " << textureUniformBayerDataIn_
 			    << " awb " << awbUniformDataIn_
 			    << " ccm " << ccmUniformDataIn_
@@ -133,7 +133,7 @@  int DebayerEGL::getShaderVariableLocations(void)
 	return 0;
 }
 
-int DebayerEGL::initBayerShaders(PixelFormat inputFormat, PixelFormat outputFormat)
+int SoftwareIspInstanceGpu::initBayerShaders(PixelFormat inputFormat, PixelFormat outputFormat)
 {
 	std::span<const unsigned char> fragmentShaderData;
 	std::span<const unsigned char> vertexShaderData;
@@ -162,7 +162,7 @@  int DebayerEGL::initBayerShaders(PixelFormat inputFormat, PixelFormat outputForm
 		egl_.pushEnv(shaderEnv, "#define SWAP_BLUE");
 		break;
 	default:
-		LOG(Debayer, Error) << "Unsupported output format";
+		LOG(SoftwareIspInstance, Error) << "Unsupported output format";
 		return -EINVAL;
 	}
 
@@ -197,7 +197,7 @@  int DebayerEGL::initBayerShaders(PixelFormat inputFormat, PixelFormat outputForm
 		firstRed_y_ = 0.0;
 		break;
 	default:
-		LOG(Debayer, Error) << "Unsupported input format";
+		LOG(SoftwareIspInstance, Error) << "Unsupported input format";
 		return -EINVAL;
 	};
 
@@ -246,20 +246,20 @@  int DebayerEGL::initBayerShaders(PixelFormat inputFormat, PixelFormat outputForm
 
 	if (egl_.compileVertexShader(vertexShaderId_, vertexShaderData,
 				     shaderEnv)) {
-		LOG(Debayer, Error) << "Compile vertex shader fail";
+		LOG(SoftwareIspInstance, Error) << "Compile vertex shader fail";
 		return -ENODEV;
 	}
 	utils::scope_exit vShaderGuard([&] { glDeleteShader(vertexShaderId_); });
 
 	if (egl_.compileFragmentShader(fragmentShaderId_, fragmentShaderData,
 				       shaderEnv)) {
-		LOG(Debayer, Error) << "Compile fragment shader fail";
+		LOG(SoftwareIspInstance, Error) << "Compile fragment shader fail";
 		return -ENODEV;
 	}
 	utils::scope_exit fShaderGuard([&] { glDeleteShader(fragmentShaderId_); });
 
 	if (egl_.linkProgram(programId_, vertexShaderId_, fragmentShaderId_)) {
-		LOG(Debayer, Error) << "Linking program fail";
+		LOG(SoftwareIspInstance, Error) << "Linking program fail";
 		return -ENODEV;
 	}
 
@@ -270,20 +270,20 @@  int DebayerEGL::initBayerShaders(PixelFormat inputFormat, PixelFormat outputForm
 	glUseProgram(programId_);
 	err = glGetError();
 	if (err != GL_NO_ERROR) {
-		LOG(Debayer, Error) << "Use program error " << err;
+		LOG(SoftwareIspInstance, Error) << "Use program error " << err;
 		return -ENODEV;
 	}
 
 	return getShaderVariableLocations();
 }
 
-int DebayerEGL::configure(const StreamConfiguration &inputCfg,
+int SoftwareIspInstanceGpu::configure(const StreamConfiguration &inputCfg,
 			  const std::vector<std::reference_wrapper<const StreamConfiguration>> &outputCfgs,
 			  [[maybe_unused]] bool ccmEnabled,
 			  bool lscEnabled)
 {
 	if (getInputConfig(inputCfg.pixelFormat, inputConfig_) != 0) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Unsupported input format " << inputCfg.pixelFormat;
 		return -EINVAL;
 	}
@@ -294,7 +294,7 @@  int DebayerEGL::configure(const StreamConfiguration &inputCfg,
 	const Size &stats_pattern_size = stats_->patternSize();
 	if (inputConfig_.patternSize.width != stats_pattern_size.width ||
 	    inputConfig_.patternSize.height != stats_pattern_size.height) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "mismatching stats and debayer pattern sizes for "
 			<< inputCfg.pixelFormat;
 		return -EINVAL;
@@ -308,7 +308,7 @@  int DebayerEGL::configure(const StreamConfiguration &inputCfg,
 	height_ = inputCfg.size.height;
 
 	if (outputCfgs.size() != 1) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Unsupported number of output streams: "
 			<< outputCfgs.size();
 		return -EINVAL;
@@ -320,7 +320,7 @@  int DebayerEGL::configure(const StreamConfiguration &inputCfg,
 		strideAndFrameSize(outputCfg.pixelFormat, outputCfg.size);
 
 	if (!outSizeRange.contains(outputCfg.size) || outputConfig_.stride != outputCfg.stride) {
-		LOG(Debayer, Error)
+		LOG(SoftwareIspInstance, Error)
 			<< "Invalid output size/stride: "
 			<< "\n  " << outputCfg.size << " (" << outSizeRange << ")"
 			<< "\n  " << outputCfg.stride << " (" << outputConfig_.stride << ")";
@@ -350,9 +350,9 @@  int DebayerEGL::configure(const StreamConfiguration &inputCfg,
 	return 0;
 }
 
-Size DebayerEGL::patternSize(PixelFormat inputFormat)
+Size SoftwareIspInstanceGpu::patternSize(PixelFormat inputFormat)
 {
-	DebayerEGL::DebayerInputConfig config;
+	SoftwareIspInstanceGpu::DebayerInputConfig config;
 
 	if (getInputConfig(inputFormat, config) != 0)
 		return {};
@@ -360,9 +360,9 @@  Size DebayerEGL::patternSize(PixelFormat inputFormat)
 	return config.patternSize;
 }
 
-std::vector<PixelFormat> DebayerEGL::formats(PixelFormat inputFormat)
+std::vector<PixelFormat> SoftwareIspInstanceGpu::formats(PixelFormat inputFormat)
 {
-	DebayerEGL::DebayerInputConfig config;
+	SoftwareIspInstanceGpu::DebayerInputConfig config;
 
 	if (getInputConfig(inputFormat, config) != 0)
 		return std::vector<PixelFormat>();
@@ -371,20 +371,20 @@  std::vector<PixelFormat> DebayerEGL::formats(PixelFormat inputFormat)
 }
 
 std::tuple<unsigned int, unsigned int>
-DebayerEGL::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
+SoftwareIspInstanceGpu::strideAndFrameSize(const PixelFormat &outputFormat, const Size &size)
 {
 	/* Align stride to 256 bytes as a generic GPU memory access alignment */
 	const PixelFormatInfo &info = PixelFormatInfo::info(outputFormat);
 	return std::make_tuple(info.stride(size.width, 0, 256), info.frameSize(size, 256));
 }
 
-uint32_t DebayerEGL::preferredInputStride(const PixelFormat &inputFormat, const Size &size)
+uint32_t SoftwareIspInstanceGpu::preferredInputStride(const PixelFormat &inputFormat, const Size &size)
 {
 	const PixelFormatInfo &info = PixelFormatInfo::info(inputFormat);
 	return info.stride(size.width, 0, 256);
 }
 
-void DebayerEGL::setShaderVariableValues(eGLImage &eglImageIn, const DebayerParams &params)
+void SoftwareIspInstanceGpu::setShaderVariableValues(eGLImage &eglImageIn, const DebayerParams &params)
 {
 	/*
 	 * Raw Bayer 8-bit, and packed raw Bayer 10-bit/12-bit formats
@@ -456,14 +456,14 @@  void DebayerEGL::setShaderVariableValues(eGLImage &eglImageIn, const DebayerPara
 	glUniform1f(textureUniformStrideFactor_, Stride);
 	glUniformMatrix4fv(textureUniformProjMatrix_, 1, GL_FALSE, projMatrix);
 
-	LOG(Debayer, Debug) << "vertexIn " << attributeVertex_ << " textureIn " << attributeTexture_
+	LOG(SoftwareIspInstance, Debug) << "vertexIn " << attributeVertex_ << " textureIn " << attributeTexture_
 			    << " tex_y " << textureUniformBayerDataIn_
 			    << " tex_step " << textureUniformStep_
 			    << " tex_size " << textureUniformSize_
 			    << " stride_factor " << textureUniformStrideFactor_
 			    << " tex_bayer_first_red " << textureUniformBayerFirstRed_;
 
-	LOG(Debayer, Debug) << "textureUniformY_ = 0 "
+	LOG(SoftwareIspInstance, Debug) << "textureUniformY_ = 0 "
 			    << " firstRed.x " << firstRed[0]
 			    << " firstRed.y " << firstRed[1]
 			    << " textureUniformSize_.width " << imgSize[0]
@@ -476,40 +476,40 @@  void DebayerEGL::setShaderVariableValues(eGLImage &eglImageIn, const DebayerPara
 	/* Pre-transpose matrix for GLES 2.0. */
 	Matrix<float, 3, 3> ccm = params.combinedMatrix.transpose();
 	glUniformMatrix3fv(ccmUniformDataIn_, 1, GL_FALSE, ccm.data().data());
-	LOG(Debayer, Debug) << " ccmUniformDataIn_ " << ccmUniformDataIn_ << " data " << params.combinedMatrix;
+	LOG(SoftwareIspInstance, Debug) << " ccmUniformDataIn_ " << ccmUniformDataIn_ << " data " << params.combinedMatrix;
 
 	if (lscEnabled_ && params.lscLutVersion != lscLutVersion_) {
 		egl_.updateTexture2D(*eglImageLscLookup_, params.lscLut.data());
 		lscLutVersion_ = params.lscLutVersion;
 		glUniform1i(textureUniformLsc_, eglImageLscLookup_->texture_unit_uniform_id_);
-		LOG(Debayer, Debug) << "LSC texture updated to version " << lscLutVersion_.value_or(-1);
+		LOG(SoftwareIspInstance, Debug) << "LSC texture updated to version " << lscLutVersion_.value_or(-1);
 	}
 
 	/*
 	 * 0 = Red, 1 = Green, 2 = Blue
 	 */
 	glUniform3f(blackLevelUniformDataIn_, params.blackLevel[0], params.blackLevel[1], params.blackLevel[2]);
-	LOG(Debayer, Debug) << " blackLevelUniformDataIn_ " << blackLevelUniformDataIn_ << " data " << params.blackLevel;
+	LOG(SoftwareIspInstance, Debug) << " blackLevelUniformDataIn_ " << blackLevelUniformDataIn_ << " data " << params.blackLevel;
 
 	glUniform3f(awbUniformDataIn_, params.gains[0], params.gains[1], params.gains[2]);
-	LOG(Debayer, Debug) << " awbUniformDataIn_ " << awbUniformDataIn_ << " data " << params.gains;
+	LOG(SoftwareIspInstance, Debug) << " awbUniformDataIn_ " << awbUniformDataIn_ << " data " << params.gains;
 
 	/*
 	 * Gamma
 	 */
 	glUniform1f(gammaUniformDataIn_, params.gamma);
-	LOG(Debayer, Debug) << " gammaUniformDataIn_ " << gammaUniformDataIn_ << " data " << params.gamma;
+	LOG(SoftwareIspInstance, Debug) << " gammaUniformDataIn_ " << gammaUniformDataIn_ << " data " << params.gamma;
 
 	/*
 	 * Contrast
 	 */
 	glUniform1f(contrastExpUniformDataIn_, params.contrastExp);
-	LOG(Debayer, Debug) << " contrastExpUniformDataIn_ " << contrastExpUniformDataIn_ << " data " << params.contrastExp;
+	LOG(SoftwareIspInstance, Debug) << " contrastExpUniformDataIn_ " << contrastExpUniformDataIn_ << " data " << params.contrastExp;
 
 	return;
 }
 
-eGLImage *DebayerEGL::getCachedInputFrameBuffer(FrameBuffer *input, std::optional<MappedFrameBuffer> *inMapped, std::optional<DmaSyncer> *inDmaSyncer)
+eGLImage *SoftwareIspInstanceGpu::getCachedInputFrameBuffer(FrameBuffer *input, std::optional<MappedFrameBuffer> *inMapped, std::optional<DmaSyncer> *inDmaSyncer)
 {
 	const SharedFD &fd = input->planes()[0].fd;
 	bool cache_miss = true;
@@ -526,7 +526,7 @@  eGLImage *DebayerEGL::getCachedInputFrameBuffer(FrameBuffer *input, std::optiona
 	if (cache_miss) {
 		if (eglImageInCache_.size() >= inputBufferCount_) {
 			eglImageInCache_.pop_front();
-			LOG(Debayer, Debug) << "Input cache " << inputBufferCount_ << " exceeded evicted entry";
+			LOG(SoftwareIspInstance, Debug) << "Input cache " << inputBufferCount_ << " exceeded evicted entry";
 		}
 
 		eglImageInCache_.emplace_back(fd, std::make_unique<eGLImage>(glFormat_, inputConfig_.stride / bytesPerPixel_, height_, inputConfig_.stride, GL_TEXTURE0, 0));
@@ -536,7 +536,7 @@  eGLImage *DebayerEGL::getCachedInputFrameBuffer(FrameBuffer *input, std::optiona
 			return eglImageIn;
 
 		if (eglImageInCache_.size() == 1)
-			LOG(Debayer, Info)
+			LOG(SoftwareIspInstance, Info)
 				<< "Importing input DMABuf failed, falling back to upload";
 	} else if (!eglImageIn->dmabuf_import_failed_) {
 		egl_.activateBindTexture(*eglImageIn);
@@ -547,7 +547,7 @@  eGLImage *DebayerEGL::getCachedInputFrameBuffer(FrameBuffer *input, std::optiona
 	inDmaSyncer->emplace(input->planes()[0].fd, DmaSyncer::SyncType::Read);
 	inMapped->emplace(input, MappedFrameBuffer::MapFlag::Read);
 	if (!inMapped->value().isValid()) {
-		LOG(Debayer, Error) << "mmap-ing buffer(s) failed";
+		LOG(SoftwareIspInstance, Error) << "mmap-ing buffer(s) failed";
 		if (cache_miss) {
 			eglImageInCache_.pop_back();
 		}
@@ -561,7 +561,7 @@  eGLImage *DebayerEGL::getCachedInputFrameBuffer(FrameBuffer *input, std::optiona
 	return eglImageIn;
 }
 
-eGLImage *DebayerEGL::getCachedOutputFrameBuffer(FrameBuffer *output)
+eGLImage *SoftwareIspInstanceGpu::getCachedOutputFrameBuffer(FrameBuffer *output)
 {
 	const SharedFD &fd = output->planes()[0].fd;
 	bool cache_miss = true;
@@ -578,7 +578,7 @@  eGLImage *DebayerEGL::getCachedOutputFrameBuffer(FrameBuffer *output)
 	if (cache_miss) {
 		if (eglImageOutCache_.size() >= outputBufferCount_) {
 			eglImageOutCache_.pop_front();
-			LOG(Debayer, Debug) << "Output cache " << outputBufferCount_ << " exceeded evicted entry";
+			LOG(SoftwareIspInstance, Debug) << "Output cache " << outputBufferCount_ << " exceeded evicted entry";
 		}
 
 		eglImageOutCache_.emplace_back(fd, std::make_unique<eGLImage>(GL_RGBA, outputSize_.width,
@@ -594,7 +594,7 @@  eGLImage *DebayerEGL::getCachedOutputFrameBuffer(FrameBuffer *output)
 	return eglImageOut;
 }
 
-int DebayerEGL::debayerGPU(FrameBuffer *input, FrameBuffer *output, const DebayerParams &params, std::optional<MappedFrameBuffer> *inMapped, std::optional<DmaSyncer> *inDmaSyncer)
+int SoftwareIspInstanceGpu::debayerGPU(FrameBuffer *input, FrameBuffer *output, const DebayerParams &params, std::optional<MappedFrameBuffer> *inMapped, std::optional<DmaSyncer> *inDmaSyncer)
 {
 	eGLImage *eglImageIn;
 	eGLImage *eglImageOut;
@@ -624,7 +624,7 @@  int DebayerEGL::debayerGPU(FrameBuffer *input, FrameBuffer *output, const Debaye
 	return 0;
 }
 
-void DebayerEGL::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, const DebayerParams &params)
+void SoftwareIspInstanceGpu::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output, const DebayerParams &params)
 {
 	egl_.assertThread();
 	bench_.startFrame();
@@ -639,7 +639,7 @@  void DebayerEGL::process(uint32_t frame, FrameBuffer *input, FrameBuffer *output
 	std::optional<DmaSyncer> inDmaSyncer;
 
 	if (debayerGPU(input, output, params, &inMapped, &inDmaSyncer)) {
-		LOG(Debayer, Error) << "debayerGPU failed";
+		LOG(SoftwareIspInstance, Error) << "debayerGPU failed";
 		goto error;
 	}
 
@@ -677,7 +677,7 @@  error:
 	return;
 }
 
-int DebayerEGL::start()
+int SoftwareIspInstanceGpu::start()
 {
 	GLint maxTextureImageUnits;
 
@@ -686,7 +686,7 @@  int DebayerEGL::start()
 
 	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureImageUnits);
 
-	LOG(Debayer, Debug) << "Available fragment shader texture units " << maxTextureImageUnits;
+	LOG(SoftwareIspInstance, Debug) << "Available fragment shader texture units " << maxTextureImageUnits;
 
 	if (initBayerShaders(inputPixelFormat_, outputPixelFormat_))
 		return -EINVAL;
@@ -706,7 +706,7 @@  int DebayerEGL::start()
 	return 0;
 }
 
-void DebayerEGL::stop()
+void SoftwareIspInstanceGpu::stop()
 {
 	eglImageOutCache_.clear();
 	eglImageInCache_.clear();
@@ -720,7 +720,7 @@  void DebayerEGL::stop()
 	egl_.resetEGLContext();
 }
 
-SizeRange DebayerEGL::sizes(PixelFormat inputFormat, const Size &inputSize)
+SizeRange SoftwareIspInstanceGpu::sizes(PixelFormat inputFormat, const Size &inputSize)
 {
 	Size patternSize = this->patternSize(inputFormat);
 	unsigned int borderHeight = patternSize.height;
@@ -738,7 +738,7 @@  SizeRange DebayerEGL::sizes(PixelFormat inputFormat, const Size &inputSize)
 	 */
 	if (inputSize.width < (3 * patternSize.width) ||
 	    inputSize.height < (2 * borderHeight + patternSize.height)) {
-		LOG(Debayer, Warning)
+		LOG(SoftwareIspInstance, Warning)
 			<< "Input format size too small: " << inputSize;
 		return {};
 	}
diff --git a/src/libcamera/software_isp/debayer_egl.h b/src/libcamera/software_isp/software_isp_instance_gpu.h
similarity index 94%
rename from src/libcamera/software_isp/debayer_egl.h
rename to src/libcamera/software_isp/software_isp_instance_gpu.h
index cbbc6a450..90cab1b9e 100644
--- a/src/libcamera/software_isp/debayer_egl.h
+++ b/src/libcamera/software_isp/software_isp_instance_gpu.h
@@ -28,7 +28,7 @@ 
 #include <EGL/eglext.h>
 #include <GLES3/gl32.h>
 
-#include "debayer.h"
+#include "software_isp_instance.h"
 
 namespace libcamera {
 
@@ -37,11 +37,11 @@  namespace libcamera {
 
 class CameraManager;
 
-class DebayerEGL : public Debayer
+class SoftwareIspInstanceGpu : public SoftwareIspInstance
 {
 public:
-	DebayerEGL(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm, EGLDisplay display);
-	~DebayerEGL();
+	SoftwareIspInstanceGpu(std::unique_ptr<SwStatsCpu> stats, const CameraManager &cm, EGLDisplay display);
+	~SoftwareIspInstanceGpu();
 
 	int configure(const StreamConfiguration &inputCfg,
 		      const std::vector<std::reference_wrapper<const StreamConfiguration>> &outputCfgs,