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,
