diff --git a/include/libcamera/internal/request.h b/include/libcamera/internal/request.h
index 9dadd6c6..e51aee8c 100644
--- a/include/libcamera/internal/request.h
+++ b/include/libcamera/internal/request.h
@@ -42,6 +42,8 @@ class Request::Private : public Extensible::Private
 	void prepare(std::chrono::milliseconds timeout = 0ms);
 	Signal<> prepared;
 
+	void setError(Errors error);
+
 private:
 	friend class PipelineHandler;
 	friend std::ostream &operator<<(std::ostream &out, const Request &r);
@@ -59,6 +61,8 @@ class Request::Private : public Extensible::Private
 	std::unordered_set<FrameBuffer *> pending_;
 	std::map<FrameBuffer *, std::unique_ptr<EventNotifier>> notifiers_;
 	std::unique_ptr<Timer> timer_;
+
+	Errors error_;
 };
 
 } /* namespace libcamera */
diff --git a/include/libcamera/request.h b/include/libcamera/request.h
index dffde153..2f716123 100644
--- a/include/libcamera/request.h
+++ b/include/libcamera/request.h
@@ -15,6 +15,7 @@
 #include <unordered_set>
 
 #include <libcamera/base/class.h>
+#include <libcamera/base/flags.h>
 #include <libcamera/base/signal.h>
 
 #include <libcamera/controls.h>
@@ -43,6 +44,14 @@ class Request : public Extensible
 		ReuseBuffers = (1 << 0),
 	};
 
+	enum ErrorId {
+		NoError = 0,
+		ControlError = (1 << 0),
+		PFCError = (1 << 1),
+	};
+
+	using Errors = Flags<ErrorId>;
+
 	using BufferMap = std::map<const Stream *, FrameBuffer *>;
 
 	Request(Camera *camera, uint64_t cookie = 0);
@@ -60,6 +69,7 @@ class Request : public Extensible
 	uint32_t sequence() const;
 	uint64_t cookie() const { return cookie_; }
 	Status status() const { return status_; }
+	Errors error() const;
 
 	bool hasPendingBuffers() const;
 
diff --git a/src/ipa/ipu3/algorithms/af.cpp b/src/ipa/ipu3/algorithms/af.cpp
index d07521a0..29a9f520 100644
--- a/src/ipa/ipu3/algorithms/af.cpp
+++ b/src/ipa/ipu3/algorithms/af.cpp
@@ -116,7 +116,10 @@ Af::Af()
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void Af::prepare(IPAContext &context, ipu3_uapi_params *params)
+void Af::prepare(IPAContext &context,
+		 [[maybe_unused]] unsigned int frame,
+		 [[maybe_unused]] IPU3FrameContext &frameContext,
+		 ipu3_uapi_params *params)
 {
 	const struct ipu3_uapi_grid_config &grid = context.configuration.af.afGrid;
 	params->acc_param.af.grid_cfg = grid;
@@ -406,6 +409,7 @@ bool Af::afIsOutOfFocus(IPAContext context)
 /**
  * \brief Determine the max contrast image and lens position.
  * \param[in] context The IPA context.
+ * \param[in] frame The frame context sequence number
  * \param[in] frameContext The current frame context
  * \param[in] stats The statistics buffer of IPU3.
  *
@@ -420,7 +424,9 @@ bool Af::afIsOutOfFocus(IPAContext context)
  *
  * [1] Hill Climbing Algorithm, https://en.wikipedia.org/wiki/Hill_climbing
  */
-void Af::process(IPAContext &context, [[maybe_unused]] IPAFrameContext *frameContext,
+void Af::process(IPAContext &context,
+		 [[maybe_unused]] unsigned int frame,
+		 [[maybe_unused]] IPU3FrameContext &frameContext,
 		 const ipu3_uapi_stats_3a *stats)
 {
 	/* Evaluate the AF buffer length */
diff --git a/src/ipa/ipu3/algorithms/af.h b/src/ipa/ipu3/algorithms/af.h
index ccf015f3..97711250 100644
--- a/src/ipa/ipu3/algorithms/af.h
+++ b/src/ipa/ipu3/algorithms/af.h
@@ -30,9 +30,13 @@ class Af : public Algorithm
 	Af();
 	~Af() = default;
 
-	void prepare(IPAContext &context, ipu3_uapi_params *params) override;
 	int configure(IPAContext &context, const IPAConfigInfo &configInfo) override;
-	void process(IPAContext &context, IPAFrameContext *frameContext,
+
+	void prepare(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
+		     ipu3_uapi_params *params) override;
+	void process(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
 		     const ipu3_uapi_stats_3a *stats) override;
 
 private:
diff --git a/src/ipa/ipu3/algorithms/agc.cpp b/src/ipa/ipu3/algorithms/agc.cpp
index 5bc64ae5..00ef54d4 100644
--- a/src/ipa/ipu3/algorithms/agc.cpp
+++ b/src/ipa/ipu3/algorithms/agc.cpp
@@ -183,13 +183,13 @@ utils::Duration Agc::filterExposure(utils::Duration exposureValue)
  * \param[in] yGain The gain calculated based on the relative luminance target
  * \param[in] iqMeanGain The gain calculated based on the relative luminance target
  */
-void Agc::computeExposure(IPAContext &context, IPAFrameContext *frameContext,
+void Agc::computeExposure(IPAContext &context, IPU3FrameContext &frameContext,
 			  double yGain, double iqMeanGain)
 {
 	const IPASessionConfiguration &configuration = context.configuration;
 	/* Get the effective exposure and gain applied on the sensor. */
-	uint32_t exposure = frameContext->sensor.exposure;
-	double analogueGain = frameContext->sensor.gain;
+	uint32_t exposure = frameContext.sensor.exposure;
+	double analogueGain = frameContext.sensor.gain;
 
 	/* Use the highest of the two gain estimates. */
 	double evGain = std::max(yGain, iqMeanGain);
@@ -317,13 +317,16 @@ double Agc::estimateLuminance(IPAActiveState &activeState,
 /**
  * \brief Process IPU3 statistics, and run AGC operations
  * \param[in] context The shared IPA context
+ * \param[in] frame The current frame sequence number
  * \param[in] frameContext The current frame context
  * \param[in] stats The IPU3 statistics and ISP results
  *
  * Identify the current image brightness, and use that to estimate the optimal
  * new exposure and gain for the scene.
  */
-void Agc::process(IPAContext &context, [[maybe_unused]] IPAFrameContext *frameContext,
+void Agc::process(IPAContext &context,
+		  [[maybe_unused]] unsigned int frame,
+		  IPU3FrameContext &frameContext,
 		  const ipu3_uapi_stats_3a *stats)
 {
 	/*
diff --git a/src/ipa/ipu3/algorithms/agc.h b/src/ipa/ipu3/algorithms/agc.h
index 105ae0f2..5bb9dc8f 100644
--- a/src/ipa/ipu3/algorithms/agc.h
+++ b/src/ipa/ipu3/algorithms/agc.h
@@ -28,14 +28,15 @@ class Agc : public Algorithm
 	~Agc() = default;
 
 	int configure(IPAContext &context, const IPAConfigInfo &configInfo) override;
-	void process(IPAContext &context, IPAFrameContext *frameContext,
+	void process(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
 		     const ipu3_uapi_stats_3a *stats) override;
 
 private:
 	double measureBrightness(const ipu3_uapi_stats_3a *stats,
 				 const ipu3_uapi_grid_config &grid) const;
 	utils::Duration filterExposure(utils::Duration currentExposure);
-	void computeExposure(IPAContext &context, IPAFrameContext *frameContext,
+	void computeExposure(IPAContext &context, IPU3FrameContext &frameContext,
 			     double yGain, double iqMeanGain);
 	double estimateLuminance(IPAActiveState &activeState,
 				 const ipu3_uapi_grid_config &grid,
diff --git a/src/ipa/ipu3/algorithms/awb.cpp b/src/ipa/ipu3/algorithms/awb.cpp
index 70426722..8943ead6 100644
--- a/src/ipa/ipu3/algorithms/awb.cpp
+++ b/src/ipa/ipu3/algorithms/awb.cpp
@@ -387,7 +387,9 @@ void Awb::calculateWBGains(const ipu3_uapi_stats_3a *stats)
 /**
  * \copydoc libcamera::ipa::Algorithm::process
  */
-void Awb::process(IPAContext &context, [[maybe_unused]] IPAFrameContext *frameContext,
+void Awb::process(IPAContext &context,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] IPU3FrameContext &frameContext,
 		  const ipu3_uapi_stats_3a *stats)
 {
 	calculateWBGains(stats);
@@ -429,7 +431,10 @@ constexpr uint16_t Awb::gainValue(double gain)
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void Awb::prepare(IPAContext &context, ipu3_uapi_params *params)
+void Awb::prepare(IPAContext &context,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] IPU3FrameContext &frameContext,
+		  ipu3_uapi_params *params)
 {
 	/*
 	 * Green saturation thresholds are reduced because we are using the
diff --git a/src/ipa/ipu3/algorithms/awb.h b/src/ipa/ipu3/algorithms/awb.h
index 0acd2148..094b1776 100644
--- a/src/ipa/ipu3/algorithms/awb.h
+++ b/src/ipa/ipu3/algorithms/awb.h
@@ -39,8 +39,12 @@ class Awb : public Algorithm
 	~Awb();
 
 	int configure(IPAContext &context, const IPAConfigInfo &configInfo) override;
-	void prepare(IPAContext &context, ipu3_uapi_params *params) override;
-	void process(IPAContext &context, IPAFrameContext *frameContext,
+
+	void prepare(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
+		     ipu3_uapi_params *params) override;
+	void process(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
 		     const ipu3_uapi_stats_3a *stats) override;
 
 private:
diff --git a/src/ipa/ipu3/algorithms/blc.cpp b/src/ipa/ipu3/algorithms/blc.cpp
index 78ab7bff..7b0d720a 100644
--- a/src/ipa/ipu3/algorithms/blc.cpp
+++ b/src/ipa/ipu3/algorithms/blc.cpp
@@ -39,13 +39,17 @@ BlackLevelCorrection::BlackLevelCorrection()
 /**
  * \brief Fill in the parameter structure, and enable black level correction
  * \param context The shared IPA context
+ * \param[in] frame The frame context sequence number
+ * \param[in] frameContext The FrameContext for this frame
  * \param params The IPU3 parameters
  *
  * Populate the IPU3 parameter structure with the correction values for each
  * channel and enable the corresponding ImgU block processing.
  */
 void BlackLevelCorrection::prepare([[maybe_unused]] IPAContext &context,
-			      ipu3_uapi_params *params)
+				   [[maybe_unused]] unsigned int frame,
+				   [[maybe_unused]] IPU3FrameContext &frameContext,
+				   ipu3_uapi_params *params)
 {
 	/*
 	 * The Optical Black Level correction values
diff --git a/src/ipa/ipu3/algorithms/blc.h b/src/ipa/ipu3/algorithms/blc.h
index d8da1748..36388b26 100644
--- a/src/ipa/ipu3/algorithms/blc.h
+++ b/src/ipa/ipu3/algorithms/blc.h
@@ -18,7 +18,9 @@ class BlackLevelCorrection : public Algorithm
 public:
 	BlackLevelCorrection();
 
-	void prepare(IPAContext &context, ipu3_uapi_params *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
+		     ipu3_uapi_params *params) override;
 };
 
 } /* namespace ipa::ipu3::algorithms */
diff --git a/src/ipa/ipu3/algorithms/tone_mapping.cpp b/src/ipa/ipu3/algorithms/tone_mapping.cpp
index f86e79b2..1acbea98 100644
--- a/src/ipa/ipu3/algorithms/tone_mapping.cpp
+++ b/src/ipa/ipu3/algorithms/tone_mapping.cpp
@@ -50,12 +50,16 @@ int ToneMapping::configure(IPAContext &context,
 /**
  * \brief Fill in the parameter structure, and enable gamma control
  * \param context The shared IPA context
+ * \param[in] frame The frame context sequence number
+ * \param[in] frameContext The FrameContext for this frame
  * \param params The IPU3 parameters
  *
  * Populate the IPU3 parameter structure with our tone mapping look up table and
  * enable the gamma control module in the processing blocks.
  */
 void ToneMapping::prepare([[maybe_unused]] IPAContext &context,
+			  [[maybe_unused]] unsigned int frame,
+			  [[maybe_unused]] IPU3FrameContext &frameContext,
 			  ipu3_uapi_params *params)
 {
 	/* Copy the calculated LUT into the parameters buffer. */
@@ -72,13 +76,16 @@ void ToneMapping::prepare([[maybe_unused]] IPAContext &context,
 /**
  * \brief Calculate the tone mapping look up table
  * \param context The shared IPA context
+ * \param frame The current frame sequence number
  * \param frameContext The current frame context
  * \param stats The IPU3 statistics and ISP results
  *
  * The tone mapping look up table is generated as an inverse power curve from
  * our gamma setting.
  */
-void ToneMapping::process(IPAContext &context, [[maybe_unused]] IPAFrameContext *frameContext,
+void ToneMapping::process(IPAContext &context,
+			  [[maybe_unused]] unsigned int frame,
+			  [[maybe_unused]] IPU3FrameContext &frameContext,
 			  [[maybe_unused]] const ipu3_uapi_stats_3a *stats)
 {
 	/*
diff --git a/src/ipa/ipu3/algorithms/tone_mapping.h b/src/ipa/ipu3/algorithms/tone_mapping.h
index d7d48006..a3ab285c 100644
--- a/src/ipa/ipu3/algorithms/tone_mapping.h
+++ b/src/ipa/ipu3/algorithms/tone_mapping.h
@@ -19,8 +19,10 @@ class ToneMapping : public Algorithm
 	ToneMapping();
 
 	int configure(IPAContext &context, const IPAConfigInfo &configInfo) override;
-	void prepare(IPAContext &context, ipu3_uapi_params *params) override;
-	void process(IPAContext &context, IPAFrameContext *frameContext,
+	void prepare(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext, ipu3_uapi_params *params) override;
+	void process(IPAContext &context, unsigned int frame,
+		     IPU3FrameContext &frameContext,
 		     const ipu3_uapi_stats_3a *stats) override;
 
 private:
diff --git a/src/ipa/ipu3/ipa_context.cpp b/src/ipa/ipu3/ipa_context.cpp
index 13cdb835..536d76ec 100644
--- a/src/ipa/ipu3/ipa_context.cpp
+++ b/src/ipa/ipu3/ipa_context.cpp
@@ -35,22 +35,6 @@ namespace libcamera::ipa::ipu3 {
  * most recently computed by the IPA algorithms.
  */
 
-/**
- * \struct IPAFrameContext
- * \brief Context for a frame
- *
- * The frame context stores data specific to a single frame processed by the
- * IPA. Each frame processed by the IPA has a context associated with it,
- * accessible through the IPAContext structure.
- *
- * Fields in the frame context should reflect values and controls
- * associated with the specific frame as requested by the application, and
- * as configured by the hardware. Fields can be read by algorithms to
- * determine if they should update any specific action for this frame, and
- * finally to update the metadata control lists when the frame is fully
- * completed.
- */
-
 /**
  * \struct IPAContext
  * \brief Global IPA context data shared between all algorithms
@@ -181,33 +165,16 @@ namespace libcamera::ipa::ipu3 {
  */
 
 /**
- * \brief Default constructor for IPAFrameContext
- */
-IPAFrameContext::IPAFrameContext() = default;
-
-/**
- * \brief Construct a IPAFrameContext instance
- */
-IPAFrameContext::IPAFrameContext(uint32_t id, const ControlList &reqControls)
-	: frame(id), frameControls(reqControls)
-{
-	sensor = {};
-}
-
-/**
- * \var IPAFrameContext::frame
- * \brief The frame number
- *
- * \var IPAFrameContext::frameControls
- * \brief Controls sent in by the application while queuing the request
+ * \struct IPU3FrameContext
+ * \copybrief libcamera::ipa::IPAFrameContext
  *
- * \var IPAFrameContext::sensor
+ * \var IPU3FrameContext::sensor
  * \brief Effective sensor values that were applied for the frame
  *
- * \var IPAFrameContext::sensor.exposure
+ * \var IPU3FrameContext::sensor.exposure
  * \brief Exposure time expressed as a number of lines
  *
- * \var IPAFrameContext::sensor.gain
+ * \var IPU3FrameContext::sensor.gain
  * \brief Analogue gain multiplier
  */
 
diff --git a/src/ipa/ipu3/ipa_context.h b/src/ipa/ipu3/ipa_context.h
index 42e11141..c4aa4c3f 100644
--- a/src/ipa/ipu3/ipa_context.h
+++ b/src/ipa/ipu3/ipa_context.h
@@ -8,8 +8,6 @@
 
 #pragma once
 
-#include <array>
-
 #include <linux/intel-ipu3.h>
 
 #include <libcamera/base/utils.h>
@@ -17,13 +15,12 @@
 #include <libcamera/controls.h>
 #include <libcamera/geometry.h>
 
+#include <libipa/fc_queue.h>
+
 namespace libcamera {
 
 namespace ipa::ipu3 {
 
-/* Maximum number of frame contexts to be held */
-static constexpr uint32_t kMaxFrameContexts = 16;
-
 struct IPASessionConfiguration {
 	struct {
 		ipu3_uapi_grid_config bdsGrid;
@@ -76,24 +73,19 @@ struct IPAActiveState {
 	} toneMapping;
 };
 
-struct IPAFrameContext {
-	IPAFrameContext();
-	IPAFrameContext(uint32_t id, const ControlList &reqControls);
+struct IPU3FrameContext : public IPAFrameContext {
 
 	struct {
 		uint32_t exposure;
 		double gain;
 	} sensor;
-
-	uint32_t frame;
-	ControlList frameControls;
 };
 
 struct IPAContext {
 	IPASessionConfiguration configuration;
 	IPAActiveState activeState;
 
-	std::array<IPAFrameContext, kMaxFrameContexts> frameContexts;
+	FCQueue<IPU3FrameContext> frameContexts;
 };
 
 } /* namespace ipa::ipu3 */
diff --git a/src/ipa/ipu3/ipu3.cpp b/src/ipa/ipu3/ipu3.cpp
index 2f6bb672..2b526ef3 100644
--- a/src/ipa/ipu3/ipu3.cpp
+++ b/src/ipa/ipu3/ipu3.cpp
@@ -38,6 +38,8 @@
 #include "algorithms/tone_mapping.h"
 #include "libipa/camera_sensor_helper.h"
 
+#include "ipa_context.h"
+
 /* Minimum grid width, expressed as a number of cells */
 static constexpr uint32_t kMinGridWidth = 16;
 /* Maximum grid width, expressed as a number of cells */
@@ -348,6 +350,9 @@ int IPAIPU3::start()
  */
 void IPAIPU3::stop()
 {
+	/* Clean the IPA context at the end of the streaming session. */
+	context_.frameContexts.clear();
+	context_ = {};
 }
 
 /**
@@ -454,11 +459,6 @@ int IPAIPU3::configure(const IPAConfigInfo &configInfo,
 
 	calculateBdsGrid(configInfo.bdsOutputSize);
 
-	/* Clean IPAActiveState at each reconfiguration. */
-	context_.activeState = {};
-	IPAFrameContext initFrameContext;
-	context_.frameContexts.fill(initFrameContext);
-
 	if (!validateSensorControls()) {
 		LOG(IPAIPU3, Error) << "Sensor control validation failed.";
 		return -EINVAL;
@@ -538,8 +538,10 @@ void IPAIPU3::fillParamsBuffer(const uint32_t frame, const uint32_t bufferId)
 	 */
 	params->use = {};
 
+	IPU3FrameContext frameContext = context_.frameContexts.get(frame);
+
 	for (auto const &algo : algorithms_)
-		algo->prepare(context_, params);
+		algo->prepare(context_, frame, frameContext, params);
 
 	paramsBufferReady.emit(frame);
 }
@@ -569,7 +571,7 @@ void IPAIPU3::processStatsBuffer(const uint32_t frame,
 	const ipu3_uapi_stats_3a *stats =
 		reinterpret_cast<ipu3_uapi_stats_3a *>(mem.data());
 
-	IPAFrameContext &frameContext = context_.frameContexts[frame % kMaxFrameContexts];
+	IPU3FrameContext &frameContext = context_.frameContexts.get(frame);
 
 	if (frameContext.frame != frame)
 		LOG(IPAIPU3, Warning) << "Frame " << frame << " does not match its frame context";
@@ -582,7 +584,7 @@ void IPAIPU3::processStatsBuffer(const uint32_t frame,
 	ControlList ctrls(controls::controls);
 
 	for (auto const &algo : algorithms_)
-		algo->process(context_, &frameContext, stats);
+		algo->process(context_, frame, frameContext, stats);
 
 	setControls(frame);
 
@@ -617,8 +619,10 @@ void IPAIPU3::processStatsBuffer(const uint32_t frame,
  */
 void IPAIPU3::queueRequest(const uint32_t frame, const ControlList &controls)
 {
-	/* \todo Start processing for 'frame' based on 'controls'. */
-	context_.frameContexts[frame % kMaxFrameContexts] = { frame, controls };
+	IPU3FrameContext &frameContext = context_.frameContexts.initialise(frame);
+
+	for (auto const &algo : algorithms_)
+		algo->queueRequest(context_, frame, frameContext, controls);
 }
 
 /**
diff --git a/src/ipa/ipu3/module.h b/src/ipa/ipu3/module.h
index d94fc459..6d0d50f6 100644
--- a/src/ipa/ipu3/module.h
+++ b/src/ipa/ipu3/module.h
@@ -19,7 +19,7 @@ namespace libcamera {
 
 namespace ipa::ipu3 {
 
-using Module = ipa::Module<IPAContext, IPAFrameContext, IPAConfigInfo,
+using Module = ipa::Module<IPAContext, IPU3FrameContext, IPAConfigInfo,
 			   ipu3_uapi_params, ipu3_uapi_stats_3a>;
 
 } /* namespace ipa::ipu3 */
diff --git a/src/ipa/libipa/algorithm.cpp b/src/ipa/libipa/algorithm.cpp
index 38200e57..c152b885 100644
--- a/src/ipa/libipa/algorithm.cpp
+++ b/src/ipa/libipa/algorithm.cpp
@@ -70,6 +70,8 @@ namespace ipa {
  * \fn Algorithm::prepare()
  * \brief Fill the \a params buffer with ISP processing parameters for a frame
  * \param[in] context The shared IPA context
+ * \param[in] frame The frame context sequence number
+ * \param[in] frameContext The FrameContext for this frame
  * \param[out] params The ISP specific parameters.
  *
  * This function is called for every frame when the camera is running before it
@@ -86,6 +88,7 @@ namespace ipa {
  * \brief Provide control values to the algorithm
  * \param[in] context The shared IPA context
  * \param[in] frame The frame number to apply the control values
+ * \param[in] frameContext The current frame's context
  * \param[in] controls The list of user controls
  *
  * This function is called for each request queued to the camera. It provides
@@ -101,6 +104,7 @@ namespace ipa {
  * \fn Algorithm::process()
  * \brief Process ISP statistics, and run algorithm operations
  * \param[in] context The shared IPA context
+ * \param[in] frame The frame context sequence number
  * \param[in] frameContext The current frame's context
  * \param[in] stats The IPA statistics and ISP results
  *
diff --git a/src/ipa/libipa/algorithm.h b/src/ipa/libipa/algorithm.h
index ccc659a6..f92829ad 100644
--- a/src/ipa/libipa/algorithm.h
+++ b/src/ipa/libipa/algorithm.h
@@ -38,18 +38,22 @@ class Algorithm
 	}
 
 	virtual void prepare([[maybe_unused]] typename Module::Context &context,
+			     [[maybe_unused]] unsigned int frame,
+			     [[maybe_unused]] typename Module::FrameContext &frameContext,
 			     [[maybe_unused]] typename Module::Params *params)
 	{
 	}
 
 	virtual void queueRequest([[maybe_unused]] typename Module::Context &context,
 				  [[maybe_unused]] const uint32_t frame,
+				  [[maybe_unused]] typename Module::FrameContext &frameContext,
 				  [[maybe_unused]] const ControlList &controls)
 	{
 	}
 
 	virtual void process([[maybe_unused]] typename Module::Context &context,
-			     [[maybe_unused]] typename Module::FrameContext *frameContext,
+			     [[maybe_unused]] unsigned int frame,
+			     [[maybe_unused]] typename Module::FrameContext &frameContext,
 			     [[maybe_unused]] const typename Module::Stats *stats)
 	{
 	}
diff --git a/src/ipa/libipa/fc_queue.cpp b/src/ipa/libipa/fc_queue.cpp
new file mode 100644
index 00000000..f0d0b3c7
--- /dev/null
+++ b/src/ipa/libipa/fc_queue.cpp
@@ -0,0 +1,133 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2022, Google Inc.
+ *
+ * fc_queue.cpp - IPA Frame context queue
+ */
+
+#include "fc_queue.h"
+
+#include <libcamera/base/log.h>
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(FCQueue)
+
+namespace ipa {
+
+/**
+ * \file fc_queue.h
+ * \brief Queue to access per-frame Context
+ */
+
+/**
+ * \class FCQueue
+ * \brief A support class for queueing FrameContext instances through the IPA
+ * \tparam FrameContext The IPA specific FrameContext derived class type
+ *
+ * The frame context queue provides a simple circular buffer implementation to
+ * store IPA specific context for each frame through its lifetime within the
+ * IPA.
+ *
+ * FrameContext instances are expected to be referenced by a monotonically
+ * increasing sequence count corresponding to a frame sequence number.
+ *
+ * A FrameContext is initialised for a given frame when the corresponding
+ * Request is first queued into the IPA. From that point on the FrameContext can
+ * be obtained by the IPA and its algorithms by referencing it from the frame
+ * sequence number.
+ *
+ * A frame sequence number from the image source must correspond to the request
+ * sequence number for this implementation to be supported in an IPA. It is
+ * expected that the same sequence number will be used to reference the context
+ * of the Frame from the point of queueing the request, specifying controls for
+ * a given frame, and processing of any ISP related controls and statistics for
+ * the same corresponding image.
+ *
+ * IPA specific frame context implementations shall inherit from the
+ * IPAFrameContext base class to support the minimum required features for a
+ * FrameContext, including the frame number and the error flags that relate to
+ * the frame.
+ *
+ * FrameContexts are overwritten when they are recycled and re-initialised by
+ * the first access made on them by either initialise(frame) or get(frame). It
+ * is required that the number of available slots in the frame context queue is
+ * larger or equal to the maximum number of in-flight requests a pipeline can
+ * handle to avoid overwriting frame context instances that still have to be
+ * processed.
+ *
+ * In the case an application does not queue requests to the Camera fast
+ * enough, frames can be produced and processed by the IPA without a
+ * corresponding Request being queued. In this case the IPA algorithm
+ * will try to access the FrameContext with a call to get() before it
+ * had been initialized at queueRequest() time. In this case there
+ * is now way the controls associated with the late Request could be
+ * applied in time, as the frame as already been processed by the IPA,
+ * the PFCError flag is automatically raised on the FrameContext.
+ */
+
+/**
+ * \struct IPAFrameContext
+ * \brief Context for a frame
+ *
+ * The frame context stores data specific to a single frame processed by the
+ * IPA. Each frame processed by the IPA has a context associated with it,
+ * accessible through the Frame Context Queue.
+ *
+ * Fields in the frame context should reflect values and controls associated
+ * with the specific frame as requested by the application, and as configured by
+ * the hardware. Fields can be read by algorithms to determine if they should
+ * update any specific action for this frame, and finally to update the metadata
+ * control lists when the frame is fully completed.
+ *
+ * \var IPAFrameContext::frame
+ * \brief The frame number
+ *
+ * \var IPAFrameContext::error
+ * \brief The error flags associated with the frame
+ */
+
+/**
+ * \fn FCQueue::clear()
+ * \brief Clear the context queue
+ *
+ * Reset the queue and ensure all FrameContext slots are re-initialised.
+ * IPA modules are expected to clear the frame context queue at the beginning of
+ * a new streaming session, in IPAModule::start().
+ */
+
+/**
+ * \fn FCQueue::initialise(uint32_t frame)
+ * \brief Initialize and return the Frame Context at slot specified by \a frame
+ * \param[in] frame The frame context sequence number
+ *
+ * The first call to obtain a FrameContext from the FCQueue should be handled
+ * through this call. The FrameContext will be initialised for the frame and
+ * returned to the caller if it was not already initialised.
+ *
+ * If the FrameContext was already initialized for this sequence, a warning will
+ * be reported and the previously initialized FrameContext is returned.
+ *
+ * Frame contexts are expected to be initialised when a Request is first passed
+ * to the IPA module in IPAModule::queueRequest().
+ *
+ * \return A reference to the FrameContext for sequence \a frame
+ */
+
+/**
+ * \fn FCQueue::get()
+ * \brief Obtain the Frame Context at slot specified by \a frame
+ * \param[in] frame The frame context sequence number
+ *
+ * Obtains an existing FrameContext from the queue and returns it to the caller.
+ *
+ * If the FrameContext is not correctly initialised for the \a frame, it will be
+ * initialised and a PFCError will be flagged on the context to be transferred
+ * to the Request when it completes.
+ *
+ * \return A reference to the FrameContext for sequence \a frame
+ */
+
+} /* namespace ipa */
+
+} /* namespace libcamera */
diff --git a/src/ipa/libipa/fc_queue.h b/src/ipa/libipa/fc_queue.h
new file mode 100644
index 00000000..28b58e4b
--- /dev/null
+++ b/src/ipa/libipa/fc_queue.h
@@ -0,0 +1,114 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2022, Google Inc.
+ *
+ * fc_queue.h - IPA Frame context queue
+ */
+
+#pragma once
+
+#include <array>
+
+#include <libcamera/base/log.h>
+
+#include <libcamera/request.h>
+
+namespace libcamera {
+
+LOG_DECLARE_CATEGORY(FCQueue)
+
+namespace ipa {
+
+/*
+ * Maximum number of frame contexts to be held onto
+ *
+ * \todo Should be platform-specific and match the pipeline depth
+ */
+static constexpr uint32_t kMaxFrameContexts = 16;
+
+struct IPAFrameContext {
+	unsigned int frame;
+	Request::Errors error;
+};
+
+template<typename FrameContext>
+class FCQueue : private std::array<FrameContext, kMaxFrameContexts>
+{
+private:
+	void initialise(FrameContext &frameContext, const uint32_t frame)
+	{
+		frameContext = {};
+		frameContext.frame = frame;
+	}
+
+public:
+	void clear()
+	{
+		this->fill({});
+	}
+
+	FrameContext &initialise(const uint32_t frame)
+	{
+		FrameContext &frameContext = this->at(frame & kMaxFrameContexts);
+
+		/*
+		 * Do not re-initialise if a get() call has already fetched this
+		 * frame context to preseve the error flags already raised.
+		 *
+		 * \todo If the the sequence number of the context to initialise
+		 * is smaller than the sequence number of the queue slot to use,
+		 * it means that we had a serious request underrun and more
+		 * frames than the queue size has been produced since the last
+		 * time the application has queued a request. Does this deserve
+		 * an error condition ?
+		 */
+		if (frame != 0 && frame <= frameContext.frame)
+			LOG(FCQueue, Warning)
+				<< "Frame " << frame << " already initialised";
+		else
+			initialise(frameContext, frame);
+
+		return frameContext;
+	}
+
+	FrameContext &get(uint32_t frame)
+	{
+		FrameContext &frameContext = this->at(frame & kMaxFrameContexts);
+
+		/*
+		 * If the IPA algorithms try to access a frame context slot which
+		 * has been already overwritten by a newer context, it means the
+		 * frame context queue has overflowed and the desired context
+		 * has been forever lost. The pipeline handler shall avoid
+		 * queueing more requests to the IPA than the frame context
+		 * queue size.
+		 */
+		if (frame < frameContext.frame)
+			LOG(FCQueue, Fatal)
+				<< "Frame " << frame << " has been overwritten";
+
+		if (frame == frameContext.frame)
+			return frameContext;
+
+		LOG(FCQueue, Warning)
+			<< "Obtained an uninitialised FrameContext for " << frame;
+
+		initialise(frameContext, frame);
+
+		/*
+		 * The frame context has been retrieved before it was
+		 * initialised through the initialise() call. This indicates an
+		 * algorithm attempted to access a Frame context before it was
+		 * queued to the IPA.
+		 *
+		 * Controls applied for this request may be left unhandled.
+		 */
+		frameContext.error |= Request::PFCError;
+
+		return frameContext;
+	}
+};
+
+} /* namespace ipa */
+
+} /* namespace libcamera */
diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
index fb894bc6..016b8e0e 100644
--- a/src/ipa/libipa/meson.build
+++ b/src/ipa/libipa/meson.build
@@ -3,6 +3,7 @@
 libipa_headers = files([
     'algorithm.h',
     'camera_sensor_helper.h',
+    'fc_queue.h',
     'histogram.h',
     'module.h',
 ])
@@ -10,6 +11,7 @@ libipa_headers = files([
 libipa_sources = files([
     'algorithm.cpp',
     'camera_sensor_helper.cpp',
+    'fc_queue.cpp',
     'histogram.cpp',
     'module.cpp',
 ])
diff --git a/src/ipa/rkisp1/algorithms/agc.cpp b/src/ipa/rkisp1/algorithms/agc.cpp
index a1bb7d97..60018db7 100644
--- a/src/ipa/rkisp1/algorithms/agc.cpp
+++ b/src/ipa/rkisp1/algorithms/agc.cpp
@@ -73,8 +73,8 @@ Agc::Agc()
 int Agc::configure(IPAContext &context, const IPACameraSensorInfo &configInfo)
 {
 	/* Configure the default exposure and gain. */
-	context.frameContext.agc.gain = std::max(context.configuration.agc.minAnalogueGain, kMinAnalogueGain);
-	context.frameContext.agc.exposure = 10ms / context.configuration.sensor.lineDuration;
+	context.activeState.agc.gain = std::max(context.configuration.agc.minAnalogueGain, kMinAnalogueGain);
+	context.activeState.agc.exposure = 10ms / context.configuration.sensor.lineDuration;
 
 	/*
 	 * According to the RkISP1 documentation:
@@ -98,7 +98,7 @@ int Agc::configure(IPAContext &context, const IPACameraSensorInfo &configInfo)
 	context.configuration.agc.measureWindow.h_size = 3 * configInfo.outputSize.width / 4;
 	context.configuration.agc.measureWindow.v_size = 3 * configInfo.outputSize.height / 4;
 
-	/* \todo Use actual frame index by populating it in the frameContext. */
+	/* \todo Use actual frame index by populating it in the activeState. */
 	frameCount_ = 0;
 	return 0;
 }
@@ -140,18 +140,18 @@ utils::Duration Agc::filterExposure(utils::Duration exposureValue)
 
 /**
  * \brief Estimate the new exposure and gain values
- * \param[inout] frameContext The shared IPA frame Context
+ * \param[inout] context The shared IPA Context
  * \param[in] yGain The gain calculated on the current brightness level
  * \param[in] iqMeanGain The gain calculated based on the relative luminance target
  */
 void Agc::computeExposure(IPAContext &context, double yGain, double iqMeanGain)
 {
 	IPASessionConfiguration &configuration = context.configuration;
-	IPAFrameContext &frameContext = context.frameContext;
+	IPAActiveState &activeState = context.activeState;
 
 	/* Get the effective exposure and gain applied on the sensor. */
-	uint32_t exposure = frameContext.sensor.exposure;
-	double analogueGain = frameContext.sensor.gain;
+	uint32_t exposure = activeState.sensor.exposure;
+	double analogueGain = activeState.sensor.gain;
 
 	/* Use the highest of the two gain estimates. */
 	double evGain = std::max(yGain, iqMeanGain);
@@ -216,8 +216,8 @@ void Agc::computeExposure(IPAContext &context, double yGain, double iqMeanGain)
 			      << stepGain;
 
 	/* Update the estimated exposure and gain. */
-	frameContext.agc.exposure = shutterTime / configuration.sensor.lineDuration;
-	frameContext.agc.gain = stepGain;
+	activeState.agc.exposure = shutterTime / configuration.sensor.lineDuration;
+	activeState.agc.gain = stepGain;
 }
 
 /**
@@ -281,7 +281,8 @@ double Agc::measureBrightness(const rkisp1_cif_isp_hist_stat *hist) const
  * new exposure and gain for the scene.
  */
 void Agc::process(IPAContext &context,
-		  [[maybe_unused]] IPAFrameContext *frameContext,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] RKISP1FrameContext &frameContext,
 		  const rkisp1_stat_buffer *stats)
 {
 	const rkisp1_cif_isp_stat *params = &stats->params;
@@ -322,9 +323,12 @@ void Agc::process(IPAContext &context,
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void Agc::prepare(IPAContext &context, rkisp1_params_cfg *params)
+void Agc::prepare(IPAContext &context,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] RKISP1FrameContext &frameContext,
+		  rkisp1_params_cfg *params)
 {
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	/* Configure the measurement window. */
diff --git a/src/ipa/rkisp1/algorithms/agc.h b/src/ipa/rkisp1/algorithms/agc.h
index 1c9818b7..473dbee5 100644
--- a/src/ipa/rkisp1/algorithms/agc.h
+++ b/src/ipa/rkisp1/algorithms/agc.h
@@ -26,8 +26,11 @@ class Agc : public Algorithm
 	~Agc() = default;
 
 	int configure(IPAContext &context, const IPACameraSensorInfo &configInfo) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
-	void process(IPAContext &context, IPAFrameContext *frameContext,
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
+	void process(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
 		     const rkisp1_stat_buffer *stats) override;
 
 private:
diff --git a/src/ipa/rkisp1/algorithms/awb.cpp b/src/ipa/rkisp1/algorithms/awb.cpp
index 9f00364d..b3ffa6cd 100644
--- a/src/ipa/rkisp1/algorithms/awb.cpp
+++ b/src/ipa/rkisp1/algorithms/awb.cpp
@@ -35,9 +35,9 @@ LOG_DEFINE_CATEGORY(RkISP1Awb)
 int Awb::configure(IPAContext &context,
 		   const IPACameraSensorInfo &configInfo)
 {
-	context.frameContext.awb.gains.red = 1.0;
-	context.frameContext.awb.gains.blue = 1.0;
-	context.frameContext.awb.gains.green = 1.0;
+	context.activeState.awb.gains.red = 1.0;
+	context.activeState.awb.gains.blue = 1.0;
+	context.activeState.awb.gains.green = 1.0;
 
 	/*
 	 * Define the measurement window for AWB as a centered rectangle
@@ -70,18 +70,21 @@ uint32_t Awb::estimateCCT(double red, double green, double blue)
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void Awb::prepare(IPAContext &context, rkisp1_params_cfg *params)
+void Awb::prepare(IPAContext &context,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] RKISP1FrameContext &frameContext,
+		  rkisp1_params_cfg *params)
 {
-	params->others.awb_gain_config.gain_green_b = 256 * context.frameContext.awb.gains.green;
-	params->others.awb_gain_config.gain_blue = 256 * context.frameContext.awb.gains.blue;
-	params->others.awb_gain_config.gain_red = 256 * context.frameContext.awb.gains.red;
-	params->others.awb_gain_config.gain_green_r = 256 * context.frameContext.awb.gains.green;
+	params->others.awb_gain_config.gain_green_b = 256 * context.activeState.awb.gains.green;
+	params->others.awb_gain_config.gain_blue = 256 * context.activeState.awb.gains.blue;
+	params->others.awb_gain_config.gain_red = 256 * context.activeState.awb.gains.red;
+	params->others.awb_gain_config.gain_green_r = 256 * context.activeState.awb.gains.green;
 
 	/* Update the gains. */
 	params->module_cfg_update |= RKISP1_CIF_ISP_MODULE_AWB_GAIN;
 
 	/* If we already have configured the gains and window, return. */
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	/* Configure the gains to apply. */
@@ -120,12 +123,13 @@ void Awb::prepare(IPAContext &context, rkisp1_params_cfg *params)
  * \copydoc libcamera::ipa::Algorithm::process
  */
 void Awb::process([[maybe_unused]] IPAContext &context,
-		  [[maybe_unused]] IPAFrameContext *frameCtx,
+		  [[maybe_unused]] unsigned int frame,
+		  [[maybe_unused]] RKISP1FrameContext &frameCtx,
 		  const rkisp1_stat_buffer *stats)
 {
 	const rkisp1_cif_isp_stat *params = &stats->params;
 	const rkisp1_cif_isp_awb_stat *awb = &params->awb;
-	IPAFrameContext &frameContext = context.frameContext;
+	IPAActiveState &activeState = context.activeState;
 
 	/* Get the YCbCr mean values */
 	double yMean = awb->awb_mean[0].mean_y_or_g;
@@ -157,22 +161,22 @@ void Awb::process([[maybe_unused]] IPAContext &context,
 
 	/* Filter the values to avoid oscillations. */
 	double speed = 0.2;
-	redGain = speed * redGain + (1 - speed) * frameContext.awb.gains.red;
-	blueGain = speed * blueGain + (1 - speed) * frameContext.awb.gains.blue;
+	redGain = speed * redGain + (1 - speed) * activeState.awb.gains.red;
+	blueGain = speed * blueGain + (1 - speed) * activeState.awb.gains.blue;
 
 	/*
 	 * Gain values are unsigned integer value, range 0 to 4 with 8 bit
 	 * fractional part.
 	 */
-	frameContext.awb.gains.red = std::clamp(redGain, 0.0, 1023.0 / 256);
-	frameContext.awb.gains.blue = std::clamp(blueGain, 0.0, 1023.0 / 256);
+	activeState.awb.gains.red = std::clamp(redGain, 0.0, 1023.0 / 256);
+	activeState.awb.gains.blue = std::clamp(blueGain, 0.0, 1023.0 / 256);
 	/* Hardcode the green gain to 1.0. */
-	frameContext.awb.gains.green = 1.0;
+	activeState.awb.gains.green = 1.0;
 
-	frameContext.awb.temperatureK = estimateCCT(redMean, greenMean, blueMean);
+	activeState.awb.temperatureK = estimateCCT(redMean, greenMean, blueMean);
 
-	LOG(RkISP1Awb, Debug) << "Gain found for red: " << context.frameContext.awb.gains.red
-			      << " and for blue: " << context.frameContext.awb.gains.blue;
+	LOG(RkISP1Awb, Debug) << "Gain found for red: " << context.activeState.awb.gains.red
+			      << " and for blue: " << context.activeState.awb.gains.blue;
 }
 
 REGISTER_IPA_ALGORITHM(Awb, "Awb")
diff --git a/src/ipa/rkisp1/algorithms/awb.h b/src/ipa/rkisp1/algorithms/awb.h
index 667a8beb..c2b18ea7 100644
--- a/src/ipa/rkisp1/algorithms/awb.h
+++ b/src/ipa/rkisp1/algorithms/awb.h
@@ -20,8 +20,11 @@ class Awb : public Algorithm
 	~Awb() = default;
 
 	int configure(IPAContext &context, const IPACameraSensorInfo &configInfo) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
-	void process(IPAContext &context, IPAFrameContext *frameCtx,
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
+	void process(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameCtx,
 		     const rkisp1_stat_buffer *stats) override;
 
 private:
diff --git a/src/ipa/rkisp1/algorithms/blc.cpp b/src/ipa/rkisp1/algorithms/blc.cpp
index a58569fa..93c7e314 100644
--- a/src/ipa/rkisp1/algorithms/blc.cpp
+++ b/src/ipa/rkisp1/algorithms/blc.cpp
@@ -66,9 +66,11 @@ int BlackLevelCorrection::init([[maybe_unused]] IPAContext &context,
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
 void BlackLevelCorrection::prepare(IPAContext &context,
+				   [[maybe_unused]] unsigned int frame,
+				   [[maybe_unused]] RKISP1FrameContext &frameContext,
 				   rkisp1_params_cfg *params)
 {
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	if (!tuningParameters_)
diff --git a/src/ipa/rkisp1/algorithms/blc.h b/src/ipa/rkisp1/algorithms/blc.h
index 5fc3a80f..1afa12f6 100644
--- a/src/ipa/rkisp1/algorithms/blc.h
+++ b/src/ipa/rkisp1/algorithms/blc.h
@@ -20,7 +20,9 @@ class BlackLevelCorrection : public Algorithm
 	~BlackLevelCorrection() = default;
 
 	int init(IPAContext &context, const YamlObject &tuningData) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 
 private:
 	bool tuningParameters_;
diff --git a/src/ipa/rkisp1/algorithms/cproc.cpp b/src/ipa/rkisp1/algorithms/cproc.cpp
index bca5ab69..c0792926 100644
--- a/src/ipa/rkisp1/algorithms/cproc.cpp
+++ b/src/ipa/rkisp1/algorithms/cproc.cpp
@@ -38,9 +38,10 @@ LOG_DEFINE_CATEGORY(RkISP1CProc)
  */
 void ColorProcessing::queueRequest(IPAContext &context,
 				   [[maybe_unused]] const uint32_t frame,
+				   [[maybe_unused]] RKISP1FrameContext &frameContext,
 				   const ControlList &controls)
 {
-	auto &cproc = context.frameContext.cproc;
+	auto &cproc = context.activeState.cproc;
 
 	const auto &brightness = controls.get(controls::Brightness);
 	if (brightness) {
@@ -71,9 +72,11 @@ void ColorProcessing::queueRequest(IPAContext &context,
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
 void ColorProcessing::prepare(IPAContext &context,
+			      [[maybe_unused]] unsigned int frame,
+			      [[maybe_unused]] RKISP1FrameContext &frameContext,
 			      rkisp1_params_cfg *params)
 {
-	auto &cproc = context.frameContext.cproc;
+	auto &cproc = context.activeState.cproc;
 
 	/* Check if the algorithm configuration has been updated. */
 	if (!cproc.updateParams)
diff --git a/src/ipa/rkisp1/algorithms/cproc.h b/src/ipa/rkisp1/algorithms/cproc.h
index 4b7e4064..13f8967e 100644
--- a/src/ipa/rkisp1/algorithms/cproc.h
+++ b/src/ipa/rkisp1/algorithms/cproc.h
@@ -22,8 +22,11 @@ class ColorProcessing : public Algorithm
 	~ColorProcessing() = default;
 
 	void queueRequest(IPAContext &context, const uint32_t frame,
+			  RKISP1FrameContext &frameContext,
 			  const ControlList &controls) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 };
 
 } /* namespace ipa::rkisp1::algorithms */
diff --git a/src/ipa/rkisp1/algorithms/dpcc.cpp b/src/ipa/rkisp1/algorithms/dpcc.cpp
index 69bc651e..9ba03653 100644
--- a/src/ipa/rkisp1/algorithms/dpcc.cpp
+++ b/src/ipa/rkisp1/algorithms/dpcc.cpp
@@ -232,9 +232,11 @@ int DefectPixelClusterCorrection::init([[maybe_unused]] IPAContext &context,
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
 void DefectPixelClusterCorrection::prepare(IPAContext &context,
+					   [[maybe_unused]] unsigned int frame,
+					   [[maybe_unused]] RKISP1FrameContext &frameContext,
 					   rkisp1_params_cfg *params)
 {
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	if (!initialized_)
diff --git a/src/ipa/rkisp1/algorithms/dpcc.h b/src/ipa/rkisp1/algorithms/dpcc.h
index a363f7be..ca9df9fc 100644
--- a/src/ipa/rkisp1/algorithms/dpcc.h
+++ b/src/ipa/rkisp1/algorithms/dpcc.h
@@ -20,7 +20,9 @@ class DefectPixelClusterCorrection : public Algorithm
 	~DefectPixelClusterCorrection() = default;
 
 	int init(IPAContext &context, const YamlObject &tuningData) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 
 private:
 	bool initialized_;
diff --git a/src/ipa/rkisp1/algorithms/filter.cpp b/src/ipa/rkisp1/algorithms/filter.cpp
index 8ca10fd1..8c5af213 100644
--- a/src/ipa/rkisp1/algorithms/filter.cpp
+++ b/src/ipa/rkisp1/algorithms/filter.cpp
@@ -44,9 +44,10 @@ static constexpr uint32_t kFiltModeDefault = 0x000004f2;
  */
 void Filter::queueRequest(IPAContext &context,
 			  [[maybe_unused]] const uint32_t frame,
+			  [[maybe_unused]] RKISP1FrameContext &frameContext,
 			  const ControlList &controls)
 {
-	auto &filter = context.frameContext.filter;
+	auto &filter = context.activeState.filter;
 
 	const auto &sharpness = controls.get(controls::Sharpness);
 	if (sharpness) {
@@ -85,9 +86,12 @@ void Filter::queueRequest(IPAContext &context,
 /**
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
-void Filter::prepare(IPAContext &context, rkisp1_params_cfg *params)
+void Filter::prepare(IPAContext &context,
+		     [[maybe_unused]] unsigned int frame,
+		     [[maybe_unused]] RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params)
 {
-	auto &filter = context.frameContext.filter;
+	auto &filter = context.activeState.filter;
 
 	/* Check if the algorithm configuration has been updated. */
 	if (!filter.updateParams)
diff --git a/src/ipa/rkisp1/algorithms/filter.h b/src/ipa/rkisp1/algorithms/filter.h
index 9eb170eb..b10efa20 100644
--- a/src/ipa/rkisp1/algorithms/filter.h
+++ b/src/ipa/rkisp1/algorithms/filter.h
@@ -22,8 +22,11 @@ class Filter : public Algorithm
 	~Filter() = default;
 
 	void queueRequest(IPAContext &context, const uint32_t frame,
+			  RKISP1FrameContext &frameContext,
 			  const ControlList &controls) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 };
 
 } /* namespace ipa::rkisp1::algorithms */
diff --git a/src/ipa/rkisp1/algorithms/gsl.cpp b/src/ipa/rkisp1/algorithms/gsl.cpp
index 2fd1a23d..77d841cf 100644
--- a/src/ipa/rkisp1/algorithms/gsl.cpp
+++ b/src/ipa/rkisp1/algorithms/gsl.cpp
@@ -119,9 +119,11 @@ int GammaSensorLinearization::init([[maybe_unused]] IPAContext &context,
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
 void GammaSensorLinearization::prepare(IPAContext &context,
+				       [[maybe_unused]] unsigned int frame,
+				       [[maybe_unused]] RKISP1FrameContext &frameContext,
 				       rkisp1_params_cfg *params)
 {
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	if (!initialized_)
diff --git a/src/ipa/rkisp1/algorithms/gsl.h b/src/ipa/rkisp1/algorithms/gsl.h
index db287dc2..fe74ae10 100644
--- a/src/ipa/rkisp1/algorithms/gsl.h
+++ b/src/ipa/rkisp1/algorithms/gsl.h
@@ -20,7 +20,9 @@ class GammaSensorLinearization : public Algorithm
 	~GammaSensorLinearization() = default;
 
 	int init(IPAContext &context, const YamlObject &tuningData) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 
 private:
 	bool initialized_;
diff --git a/src/ipa/rkisp1/algorithms/lsc.cpp b/src/ipa/rkisp1/algorithms/lsc.cpp
index 05c8c0da..cd8fcbe6 100644
--- a/src/ipa/rkisp1/algorithms/lsc.cpp
+++ b/src/ipa/rkisp1/algorithms/lsc.cpp
@@ -123,9 +123,11 @@ int LensShadingCorrection::init([[maybe_unused]] IPAContext &context,
  * \copydoc libcamera::ipa::Algorithm::prepare
  */
 void LensShadingCorrection::prepare(IPAContext &context,
+				    [[maybe_unused]] unsigned int frame,
+				    [[maybe_unused]] RKISP1FrameContext &frameContext,
 				    rkisp1_params_cfg *params)
 {
-	if (context.frameContext.frameCount > 0)
+	if (context.activeState.frameCount > 0)
 		return;
 
 	if (!initialized_)
diff --git a/src/ipa/rkisp1/algorithms/lsc.h b/src/ipa/rkisp1/algorithms/lsc.h
index fdb2ec1d..fafb80b3 100644
--- a/src/ipa/rkisp1/algorithms/lsc.h
+++ b/src/ipa/rkisp1/algorithms/lsc.h
@@ -20,7 +20,9 @@ class LensShadingCorrection : public Algorithm
 	~LensShadingCorrection() = default;
 
 	int init(IPAContext &context, const YamlObject &tuningData) override;
-	void prepare(IPAContext &context, rkisp1_params_cfg *params) override;
+	void prepare(IPAContext &context, unsigned int frame,
+		     RKISP1FrameContext &frameContext,
+		     rkisp1_params_cfg *params) override;
 
 private:
 	bool initialized_;
diff --git a/src/ipa/rkisp1/ipa_context.h b/src/ipa/rkisp1/ipa_context.h
index 2bdb6a81..dd756f40 100644
--- a/src/ipa/rkisp1/ipa_context.h
+++ b/src/ipa/rkisp1/ipa_context.h
@@ -14,6 +14,8 @@
 
 #include <libcamera/geometry.h>
 
+#include <libipa/fc_queue.h>
+
 namespace libcamera {
 
 namespace ipa::rkisp1 {
@@ -41,7 +43,7 @@ struct IPASessionConfiguration {
 	} hw;
 };
 
-struct IPAFrameContext {
+struct IPAActiveState {
 	struct {
 		uint32_t exposure;
 		double gain;
@@ -78,9 +80,14 @@ struct IPAFrameContext {
 	unsigned int frameCount;
 };
 
+struct RKISP1FrameContext : public IPAFrameContext {
+};
+
 struct IPAContext {
 	IPASessionConfiguration configuration;
-	IPAFrameContext frameContext;
+	IPAActiveState activeState;
+
+	FCQueue<RKISP1FrameContext> frameContexts;
 };
 
 } /* namespace ipa::rkisp1 */
diff --git a/src/ipa/rkisp1/module.h b/src/ipa/rkisp1/module.h
index 89f83208..2568c624 100644
--- a/src/ipa/rkisp1/module.h
+++ b/src/ipa/rkisp1/module.h
@@ -19,7 +19,7 @@ namespace libcamera {
 
 namespace ipa::rkisp1 {
 
-using Module = ipa::Module<IPAContext, IPAFrameContext, IPACameraSensorInfo,
+using Module = ipa::Module<IPAContext, RKISP1FrameContext, IPACameraSensorInfo,
 			   rkisp1_params_cfg, rkisp1_stat_buffer>;
 
 } /* namespace ipa::rkisp1 */
diff --git a/src/ipa/rkisp1/rkisp1.cpp b/src/ipa/rkisp1/rkisp1.cpp
index 6cf4d169..7821e549 100644
--- a/src/ipa/rkisp1/rkisp1.cpp
+++ b/src/ipa/rkisp1/rkisp1.cpp
@@ -49,7 +49,7 @@ class IPARkISP1 : public IPARkISP1Interface, public Module
 	int init(const IPASettings &settings, unsigned int hwRevision,
 		 ControlInfoMap *ipaControls) override;
 	int start() override;
-	void stop() override {}
+	void stop() override;
 
 	int configure(const IPACameraSensorInfo &info,
 		      const std::map<uint32_t, IPAStream> &streamConfig,
@@ -184,11 +184,21 @@ int IPARkISP1::init(const IPASettings &settings, unsigned int hwRevision,
 
 int IPARkISP1::start()
 {
+	/* Clean the IPA context before starting the streaming session. */
+	context_ = {};
+
 	setControls(0);
 
 	return 0;
 }
 
+void IPARkISP1::stop()
+{
+	/* Clean the IPA context at the end of the streaming session. */
+	context_.frameContexts.clear();
+	context_ = {};
+}
+
 /**
  * \todo The RkISP1 pipeline currently provides an empty IPACameraSensorInfo
  * if the connected sensor does not provide enough information to properly
@@ -228,9 +238,6 @@ int IPARkISP1::configure([[maybe_unused]] const IPACameraSensorInfo &info,
 		<< "Exposure: " << minExposure << "-" << maxExposure
 		<< " Gain: " << minGain << "-" << maxGain;
 
-	/* Clean context at configuration */
-	context_ = {};
-
 	/* Set the hardware revision for the algorithms. */
 	context_.configuration.hw.revision = hwRevision_;
 
@@ -249,7 +256,7 @@ int IPARkISP1::configure([[maybe_unused]] const IPACameraSensorInfo &info,
 	context_.configuration.agc.minAnalogueGain = camHelper_->gain(minGain);
 	context_.configuration.agc.maxAnalogueGain = camHelper_->gain(maxGain);
 
-	context_.frameContext.frameCount = 0;
+	context_.activeState.frameCount = 0;
 
 	for (auto const &algo : algorithms()) {
 		int ret = algo->configure(context_, info);
@@ -292,12 +299,16 @@ void IPARkISP1::unmapBuffers(const std::vector<unsigned int> &ids)
 
 void IPARkISP1::queueRequest(const uint32_t frame, const ControlList &controls)
 {
+	RKISP1FrameContext &frameContext = context_.frameContexts.initialise(frame);
+
 	for (auto const &algo : algorithms())
-		algo->queueRequest(context_, frame, controls);
+		algo->queueRequest(context_, frame, frameContext, controls);
 }
 
 void IPARkISP1::fillParamsBuffer(const uint32_t frame, const uint32_t bufferId)
 {
+	RKISP1FrameContext &frameContext = context_.frameContexts.get(frame);
+
 	rkisp1_params_cfg *params =
 		reinterpret_cast<rkisp1_params_cfg *>(
 			mappedBuffers_.at(bufferId).planes()[0].data());
@@ -306,28 +317,30 @@ void IPARkISP1::fillParamsBuffer(const uint32_t frame, const uint32_t bufferId)
 	memset(params, 0, sizeof(*params));
 
 	for (auto const &algo : algorithms())
-		algo->prepare(context_, params);
+		algo->prepare(context_, frame, frameContext, params);
 
 	paramsBufferReady.emit(frame);
-	context_.frameContext.frameCount++;
+	context_.activeState.frameCount++;
 }
 
 void IPARkISP1::processStatsBuffer(const uint32_t frame, const uint32_t bufferId,
 				   const ControlList &sensorControls)
 {
+	RKISP1FrameContext &frameContext = context_.frameContexts.get(frame);
+
 	const rkisp1_stat_buffer *stats =
 		reinterpret_cast<rkisp1_stat_buffer *>(
 			mappedBuffers_.at(bufferId).planes()[0].data());
 
-	context_.frameContext.sensor.exposure =
+	context_.activeState.sensor.exposure =
 		sensorControls.get(V4L2_CID_EXPOSURE).get<int32_t>();
-	context_.frameContext.sensor.gain =
+	context_.activeState.sensor.gain =
 		camHelper_->gain(sensorControls.get(V4L2_CID_ANALOGUE_GAIN).get<int32_t>());
 
 	unsigned int aeState = 0;
 
 	for (auto const &algo : algorithms())
-		algo->process(context_, nullptr, stats);
+		algo->process(context_, frame, frameContext, stats);
 
 	setControls(frame);
 
@@ -336,8 +349,8 @@ void IPARkISP1::processStatsBuffer(const uint32_t frame, const uint32_t bufferId
 
 void IPARkISP1::setControls(unsigned int frame)
 {
-	uint32_t exposure = context_.frameContext.agc.exposure;
-	uint32_t gain = camHelper_->gainCode(context_.frameContext.agc.gain);
+	uint32_t exposure = context_.activeState.agc.exposure;
+	uint32_t gain = camHelper_->gainCode(context_.activeState.agc.gain);
 
 	ControlList ctrls(ctrls_);
 	ctrls.set(V4L2_CID_EXPOSURE, static_cast<int32_t>(exposure));
diff --git a/src/libcamera/pipeline/uvcvideo/uvcvideo.cpp b/src/libcamera/pipeline/uvcvideo/uvcvideo.cpp
index fbe02cdc..8ffa27b1 100644
--- a/src/libcamera/pipeline/uvcvideo/uvcvideo.cpp
+++ b/src/libcamera/pipeline/uvcvideo/uvcvideo.cpp
@@ -26,6 +26,7 @@
 #include "libcamera/internal/device_enumerator.h"
 #include "libcamera/internal/media_device.h"
 #include "libcamera/internal/pipeline_handler.h"
+#include "libcamera/internal/request.h"
 #include "libcamera/internal/sysfs.h"
 #include "libcamera/internal/v4l2_videodevice.h"
 
@@ -373,8 +374,10 @@ int PipelineHandlerUVC::queueRequestDevice(Camera *camera, Request *request)
 	}
 
 	int ret = processControls(data, request);
-	if (ret < 0)
-		return ret;
+	if (ret < 0) {
+		LOG(UVC, Error) << "Failed to process controls";
+		request->_d()->setError(Request::ControlError);
+	}
 
 	ret = data->video_->queueBuffer(buffer);
 	if (ret < 0)
diff --git a/src/libcamera/request.cpp b/src/libcamera/request.cpp
index d2af1d22..18dfdcc1 100644
--- a/src/libcamera/request.cpp
+++ b/src/libcamera/request.cpp
@@ -162,6 +162,7 @@ void Request::Private::cancel()
  */
 void Request::Private::reuse()
 {
+	error_ = Request::NoError;
 	sequence_ = 0;
 	cancelled_ = false;
 	prepared_ = false;
@@ -284,6 +285,21 @@ void Request::Private::notifierActivated(FrameBuffer *buffer)
 	emitPrepareCompleted();
 }
 
+/**
+ * \brief Update the error flags of the Request
+ * \param[in] error Error flags to apply on the Request
+ *
+ * Flag \a error in the Request which will get reported to the application when
+ * the Request completes.
+ *
+ * Setting an error flag does not cause a Request to fail, and once set it can
+ * only be cleared by the application destroying the Request or calling reuse().
+ */
+void Request::Private::setError(Errors error)
+{
+	error_ |= error;
+}
+
 void Request::Private::timeout()
 {
 	/* A timeout can only happen if there are fences not yet signalled. */
@@ -318,6 +334,29 @@ void Request::Private::timeout()
  * Reuse the buffers that were previously added by addBuffer()
  */
 
+/**
+ * \enum Request::ErrorId
+ * Flags to report errors on a completed request
+ *
+ * \var Request::NoError
+ * No error. The Request completed succesfully and all its buffer contain
+ * valid data
+ *
+ * \var Request::ControlError
+ * Control Error. At least one control was not applied correctly to the camera.
+ * The application should compare the metadata to the requested control values
+ * to check which controls weren't applied.
+ *
+ * \var Request::PFCError
+ * A per-frame-control error has occured. Controls that were expected to be set
+ * during the processing of this request were not processed in time.
+ */
+
+/**
+ * \typedef Request::Errors
+ * The error state of the request defined by \a Request::ErrorId
+ */
+
 /**
  * \typedef Request::BufferMap
  * \brief A map of Stream to FrameBuffer pointers
@@ -552,14 +591,43 @@ uint32_t Request::sequence() const
  * \brief Retrieve the request completion status
  *
  * The request status indicates whether the request has completed successfully
- * or with an error. When requests are created and before they complete the
- * request status is set to RequestPending, and is updated at completion time
- * to RequestComplete. If a request is cancelled at capture stop before it has
- * completed, its status is set to RequestCancelled.
+ * or has been cancelled before being processed.
+ *
+ * Requests are created with their status set to RequestPending. When
+ * a Request is successfully processed and completed by the Camera its
+ * status is set to RequestComplete. If a Request is cancelled before
+ * being processed, for example because the Camera has been stopped
+ * before the request is completed, its status is set to RequestCancelled.
+ *
+ * Successfully completed requests can complete with errors. Applications shall
+ * inspect the error mask returned by Request::error() before accessing buffers
+ * and data associated with a completed request.
  *
  * \return The request completion status
  */
 
+/**
+ * \brief Retrieve the mask of error flags associated with a completed request
+ *
+ * The request could complete with errors, which indicate failures in
+ * completing correctly parts of the request submitted by the application.
+ *
+ * The possible failure reasons are defined by the error flags defined
+ * by Request::ErrorId and application are expected to retrieve the
+ * mask of error flags by using this function before accessing the
+ * buffers and data associated with a completed request.
+ *
+ * Error conditions reported through this function do not change the
+ * request completion status retrieved through Request::status() which
+ * indicates if the Request has been processed or not.
+ *
+ * \return A mask of error identifier with which the request was completed
+ */
+Request::Errors Request::error() const
+{
+	return _d()->error_;
+}
+
 /**
  * \brief Check if a request has buffers yet to be completed
  *