5 files changed, 821 insertions, 0 deletions
diff --git a/src/libcamera/pipeline/rpi/common/delayed_controls.cpp b/src/libcamera/pipeline/rpi/common/delayed_controls.cpp
new file mode 100644
index 00000000..3db92e7d
--- /dev/null
+++ b/src/libcamera/pipeline/rpi/common/delayed_controls.cpp
@@ -0,0 +1,293 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Raspberry Pi Ltd
+ *
+ * delayed_controls.cpp - Helper to deal with controls that take effect with a delay
+ *
+ * Note: This has been forked from the libcamera core implementation.
+ */
+
+#include "delayed_controls.h"
+
+#include <libcamera/base/log.h>
+
+#include <libcamera/controls.h>
+
+#include "libcamera/internal/v4l2_device.h"
+
+/**
+ * \file delayed_controls.h
+ * \brief Helper to deal with controls that take effect with a delay
+ */
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(RPiDelayedControls)
+
+namespace RPi {
+
+/**
+ * \class DelayedControls
+ * \brief Helper to deal with controls that take effect with a delay
+ *
+ * Some sensor controls take effect with a delay as the sensor needs time to
+ * adjust, for example exposure and analog gain. This is a helper class to deal
+ * with such controls and the intended users are pipeline handlers.
+ *
+ * The idea is to extend the concept of the buffer depth of a pipeline the
+ * application needs to maintain to also cover controls. Just as with buffer
+ * depth if the application keeps the number of requests queued above the
+ * control depth the controls are guaranteed to take effect for the correct
+ * request. The control depth is determined by the control with the greatest
+ * delay.
+ */
+
+/**
+ * \struct DelayedControls::ControlParams
+ * \brief Parameters associated with controls handled by the \a DelayedControls
+ * helper class
+ *
+ * \var ControlParams::delay
+ * \brief Frame delay from setting the control on a sensor device to when it is
+ * consumed during framing.
+ *
+ * \var ControlParams::priorityWrite
+ * \brief Flag to indicate that this control must be applied ahead of, and
+ * separately from the other controls.
+ *
+ * Typically set for the \a V4L2_CID_VBLANK control so that the device driver
+ * does not reject \a V4L2_CID_EXPOSURE control values that may be outside of
+ * the existing vertical blanking specified bounds, but are within the new
+ * blanking bounds.
+ */
+
+/**
+ * \brief Construct a DelayedControls instance
+ * \param[in] device The V4L2 device the controls have to be applied to
+ * \param[in] controlParams Map of the numerical V4L2 control ids to their
+ * associated control parameters.
+ *
+ * The control parameters comprise of delays (in frames) and a priority write
+ * flag. If this flag is set, the relevant control is written separately from,
+ * and ahead of the rest of the batched controls.
+ *
+ * Only controls specified in \a controlParams are handled. If it's desired to
+ * mix delayed controls and controls that take effect immediately the immediate
+ * controls must be listed in the \a controlParams map with a delay value of 0.
+ */
+DelayedControls::DelayedControls(V4L2Device *device,
+				 const std::unordered_map<uint32_t, ControlParams> &controlParams)
+	: device_(device), maxDelay_(0)
+{
+	const ControlInfoMap &controls = device_->controls();
+
+	/*
+	 * Create a map of control ids to delays for controls exposed by the
+	 * device.
+	 */
+	for (auto const &param : controlParams) {
+		auto it = controls.find(param.first);
+		if (it == controls.end()) {
+			LOG(RPiDelayedControls, Error)
+				<< "Delay request for control id "
+				<< utils::hex(param.first)
+				<< " but control is not exposed by device "
+				<< device_->deviceNode();
+			continue;
+		}
+
+		const ControlId *id = it->first;
+
+		controlParams_[id] = param.second;
+
+		LOG(RPiDelayedControls, Debug)
+			<< "Set a delay of " << controlParams_[id].delay
+			<< " and priority write flag " << controlParams_[id].priorityWrite
+			<< " for " << id->name();
+
+		maxDelay_ = std::max(maxDelay_, controlParams_[id].delay);
+	}
+
+	reset(0);
+}
+
+/**
+ * \brief Reset state machine
+ *
+ * Resets the state machine to a starting position based on control values
+ * retrieved from the device.
+ */
+void DelayedControls::reset(unsigned int cookie)
+{
+	queueCount_ = 1;
+	writeCount_ = 0;
+	cookies_[0] = cookie;
+
+	/* Retrieve control as reported by the device. */
+	std::vector<uint32_t> ids;
+	for (auto const &param : controlParams_)
+		ids.push_back(param.first->id());
+
+	ControlList controls = device_->getControls(ids);
+
+	/* Seed the control queue with the controls reported by the device. */
+	values_.clear();
+	for (const auto &ctrl : controls) {
+		const ControlId *id = device_->controls().idmap().at(ctrl.first);
+		/*
+		 * Do not mark this control value as updated, it does not need
+		 * to be written to to device on startup.
+		 */
+		values_[id][0] = Info(ctrl.second, false);
+	}
+}
+
+/**
+ * \brief Push a set of controls on the queue
+ * \param[in] controls List of controls to add to the device queue
+ *
+ * Push a set of controls to the control queue. This increases the control queue
+ * depth by one.
+ *
+ * \returns true if \a controls are accepted, or false otherwise
+ */
+bool DelayedControls::push(const ControlList &controls, const unsigned int cookie)
+{
+	/* Copy state from previous frame. */
+	for (auto &ctrl : values_) {
+		Info &info = ctrl.second[queueCount_];
+		info = values_[ctrl.first][queueCount_ - 1];
+		info.updated = false;
+	}
+
+	/* Update with new controls. */
+	const ControlIdMap &idmap = device_->controls().idmap();
+	for (const auto &control : controls) {
+		const auto &it = idmap.find(control.first);
+		if (it == idmap.end()) {
+			LOG(RPiDelayedControls, Warning)
+				<< "Unknown control " << control.first;
+			return false;
+		}
+
+		const ControlId *id = it->second;
+
+		if (controlParams_.find(id) == controlParams_.end())
+			return false;
+
+		Info &info = values_[id][queueCount_];
+
+		info = Info(control.second);
+
+		LOG(RPiDelayedControls, Debug)
+			<< "Queuing " << id->name()
+			<< " to " << info.toString()
+			<< " at index " << queueCount_;
+	}
+
+	cookies_[queueCount_] = cookie;
+	queueCount_++;
+
+	return true;
+}
+
+/**
+ * \brief Read back controls in effect at a sequence number
+ * \param[in] sequence The sequence number to get controls for
+ *
+ * Read back what controls where in effect at a specific sequence number. The
+ * history is a ring buffer of 16 entries where new and old values coexist. It's
+ * the callers responsibility to not read too old sequence numbers that have been
+ * pushed out of the history.
+ *
+ * Historic values are evicted by pushing new values onto the queue using
+ * push(). The max history from the current sequence number that yields valid
+ * values are thus 16 minus number of controls pushed.
+ *
+ * \return The controls at \a sequence number
+ */
+std::pair<ControlList, unsigned int> DelayedControls::get(uint32_t sequence)
+{
+	unsigned int index = std::max<int>(0, sequence - maxDelay_);
+
+	ControlList out(device_->controls());
+	for (const auto &ctrl : values_) {
+		const ControlId *id = ctrl.first;
+		const Info &info = ctrl.second[index];
+
+		out.set(id->id(), info);
+
+		LOG(RPiDelayedControls, Debug)
+			<< "Reading " << id->name()
+			<< " to " << info.toString()
+			<< " at index " << index;
+	}
+
+	return { out, cookies_[index] };
+}
+
+/**
+ * \brief Inform DelayedControls of the start of a new frame
+ * \param[in] sequence Sequence number of the frame that started
+ *
+ * Inform the state machine that a new frame has started and of its sequence
+ * number. Any user of these helpers is responsible to inform the helper about
+ * the start of any frame. This can be connected with ease to the start of a
+ * exposure (SOE) V4L2 event.
+ */
+void DelayedControls::applyControls(uint32_t sequence)
+{
+	LOG(RPiDelayedControls, Debug) << "frame " << sequence << " started";
+
+	/*
+	 * Create control list peeking ahead in the value queue to ensure
+	 * values are set in time to satisfy the sensor delay.
+	 */
+	ControlList out(device_->controls());
+	for (auto &ctrl : values_) {
+		const ControlId *id = ctrl.first;
+		unsigned int delayDiff = maxDelay_ - controlParams_[id].delay;
+		unsigned int index = std::max<int>(0, writeCount_ - delayDiff);
+		Info &info = ctrl.second[index];
+
+		if (info.updated) {
+			if (controlParams_[id].priorityWrite) {
+				/*
+				 * This control must be written now, it could
+				 * affect validity of the other controls.
+				 */
+				ControlList priority(device_->controls());
+				priority.set(id->id(), info);
+				device_->setControls(&priority);
+			} else {
+				/*
+				 * Batch up the list of controls and write them
+				 * at the end of the function.
+				 */
+				out.set(id->id(), info);
+			}
+
+			LOG(RPiDelayedControls, Debug)
+				<< "Setting " << id->name()
+				<< " to " << info.toString()
+				<< " at index " << index;
+
+			/* Done with this update, so mark as completed. */
+			info.updated = false;
+		}
+	}
+
+	writeCount_ = sequence + 1;
+
+	while (writeCount_ > queueCount_) {
+		LOG(RPiDelayedControls, Debug)
+			<< "Queue is empty, auto queue no-op.";
+		push({}, cookies_[queueCount_ - 1]);
+	}
+
+	device_->setControls(&out);
+}
+
+} /* namespace RPi */
+
+} /* namespace libcamera */
diff --git a/src/libcamera/pipeline/rpi/common/delayed_controls.h b/src/libcamera/pipeline/rpi/common/delayed_controls.h
new file mode 100644
index 00000000..61f755f0
--- /dev/null
+++ b/src/libcamera/pipeline/rpi/common/delayed_controls.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Raspberry Pi Ltd
+ *
+ * delayed_controls.h - Helper to deal with controls that take effect with a delay
+ *
+ * Note: This has been forked from the libcamera core implementation.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <unordered_map>
+#include <utility>
+
+#include <libcamera/controls.h>
+
+namespace libcamera {
+
+class V4L2Device;
+
+namespace RPi {
+
+class DelayedControls
+{
+public:
+	struct ControlParams {
+		unsigned int delay;
+		bool priorityWrite;
+	};
+
+	DelayedControls(V4L2Device *device,
+			const std::unordered_map<uint32_t, ControlParams> &controlParams);
+
+	void reset(unsigned int cookie);
+
+	bool push(const ControlList &controls, unsigned int cookie);
+	std::pair<ControlList, unsigned int> get(uint32_t sequence);
+
+	void applyControls(uint32_t sequence);
+
+private:
+	class Info : public ControlValue
+	{
+	public:
+		Info()
+			: updated(false)
+		{
+		}
+
+		Info(const ControlValue &v, bool updated_ = true)
+			: ControlValue(v), updated(updated_)
+		{
+		}
+
+		bool updated;
+	};
+
+	static constexpr int listSize = 16;
+	template<typename T>
+	class RingBuffer : public std::array<T, listSize>
+	{
+	public:
+		T &operator[](unsigned int index)
+		{
+			return std::array<T, listSize>::operator[](index % listSize);
+		}
+
+		const T &operator[](unsigned int index) const
+		{
+			return std::array<T, listSize>::operator[](index % listSize);
+		}
+	};
+
+	V4L2Device *device_;
+	std::unordered_map<const ControlId *, ControlParams> controlParams_;
+	unsigned int maxDelay_;
+
+	uint32_t queueCount_;
+	uint32_t writeCount_;
+	std::unordered_map<const ControlId *, RingBuffer<Info>> values_;
+	RingBuffer<unsigned int> cookies_;
+};
+
+} /* namespace RPi */
+
+} /* namespace libcamera */
diff --git a/src/libcamera/pipeline/rpi/common/meson.build b/src/libcamera/pipeline/rpi/common/meson.build
new file mode 100644
index 00000000..2ad594cf
--- /dev/null
+++ b/src/libcamera/pipeline/rpi/common/meson.build
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: CC0-1.0
+
+libcamera_sources += files([
+    'delayed_controls.cpp',
+    'rpi_stream.cpp',
+])
diff --git a/src/libcamera/pipeline/rpi/common/rpi_stream.cpp b/src/libcamera/pipeline/rpi/common/rpi_stream.cpp
new file mode 100644
index 00000000..2bb10f25
--- /dev/null
+++ b/src/libcamera/pipeline/rpi/common/rpi_stream.cpp
@@ -0,0 +1,250 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Raspberry Pi Ltd
+ *
+ * rpi_stream.cpp - Raspberry Pi device stream abstraction class.
+ */
+#include "rpi_stream.h"
+
+#include <libcamera/base/log.h>
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(RPISTREAM)
+
+namespace RPi {
+
+V4L2VideoDevice *Stream::dev() const
+{
+	return dev_.get();
+}
+
+std::string Stream::name() const
+{
+	return name_;
+}
+
+void Stream::resetBuffers()
+{
+	/* Add all internal buffers to the queue of usable buffers. */
+	availableBuffers_ = {};
+	for (auto const &buffer : internalBuffers_)
+		availableBuffers_.push(buffer.get());
+}
+
+void Stream::setExternal(bool external)
+{
+	/* Import streams cannot be external. */
+	ASSERT(!external || !importOnly_);
+	external_ = external;
+}
+
+bool Stream::isExternal() const
+{
+	return external_;
+}
+
+void Stream::setExportedBuffers(std::vector<std::unique_ptr<FrameBuffer>> *buffers)
+{
+	for (auto const &buffer : *buffers)
+		bufferMap_.emplace(id_.get(), buffer.get());
+}
+
+const BufferMap &Stream::getBuffers() const
+{
+	return bufferMap_;
+}
+
+int Stream::getBufferId(FrameBuffer *buffer) const
+{
+	if (importOnly_)
+		return -1;
+
+	/* Find the buffer in the map, and return the buffer id. */
+	auto it = std::find_if(bufferMap_.begin(), bufferMap_.end(),
+			       [&buffer](auto const &p) { return p.second == buffer; });
+
+	if (it == bufferMap_.end())
+		return -1;
+
+	return it->first;
+}
+
+void Stream::setExternalBuffer(FrameBuffer *buffer)
+{
+	bufferMap_.emplace(BufferMask::MaskExternalBuffer | id_.get(), buffer);
+}
+
+void Stream::removeExternalBuffer(FrameBuffer *buffer)
+{
+	int id = getBufferId(buffer);
+
+	/* Ensure we have this buffer in the stream, and it is marked external. */
+	ASSERT(id != -1 && (id & BufferMask::MaskExternalBuffer));
+	bufferMap_.erase(id);
+}
+
+int Stream::prepareBuffers(unsigned int count)
+{
+	int ret;
+
+	if (!importOnly_) {
+		if (count) {
+			/* Export some frame buffers for internal use. */
+			ret = dev_->exportBuffers(count, &internalBuffers_);
+			if (ret < 0)
+				return ret;
+
+			/* Add these exported buffers to the internal/external buffer list. */
+			setExportedBuffers(&internalBuffers_);
+			resetBuffers();
+		}
+
+		/* We must import all internal/external exported buffers. */
+		count = bufferMap_.size();
+	}
+
+	/*
+	 * If this is an external stream, we must allocate slots for buffers that
+	 * might be externally allocated. We have no indication of how many buffers
+	 * may be used, so this might overallocate slots in the buffer cache.
+	 * Similarly, if this stream is only importing buffers, we do the same.
+	 *
+	 * \todo Find a better heuristic, or, even better, an exact solution to
+	 * this issue.
+	 */
+	if (isExternal() || importOnly_)
+		count = count * 2;
+
+	return dev_->importBuffers(count);
+}
+
+int Stream::queueBuffer(FrameBuffer *buffer)
+{
+	/*
+	 * A nullptr buffer implies an external stream, but no external
+	 * buffer has been supplied in the Request. So, pick one from the
+	 * availableBuffers_ queue.
+	 */
+	if (!buffer) {
+		if (availableBuffers_.empty()) {
+			LOG(RPISTREAM, Debug) << "No buffers available for "
+					      << name_;
+			/*
+			 * Note that we need to queue an internal buffer as soon
+			 * as one becomes available.
+			 */
+			requestBuffers_.push(nullptr);
+			return 0;
+		}
+
+		buffer = availableBuffers_.front();
+		availableBuffers_.pop();
+	}
+
+	/*
+	 * If no earlier requests are pending to be queued we can go ahead and
+	 * queue this buffer into the device.
+	 */
+	if (requestBuffers_.empty())
+		return queueToDevice(buffer);
+
+	/*
+	 * There are earlier Request buffers to be queued, so this buffer must go
+	 * on the waiting list.
+	 */
+	requestBuffers_.push(buffer);
+
+	return 0;
+}
+
+void Stream::returnBuffer(FrameBuffer *buffer)
+{
+	if (!external_) {
+		/* For internal buffers, simply requeue back to the device. */
+		queueToDevice(buffer);
+		return;
+	}
+
+	/* Push this buffer back into the queue to be used again. */
+	availableBuffers_.push(buffer);
+
+	/* Allow the buffer id to be reused. */
+	id_.release(getBufferId(buffer));
+
+	/*
+	 * Do we have any Request buffers that are waiting to be queued?
+	 * If so, do it now as availableBuffers_ will not be empty.
+	 */
+	while (!requestBuffers_.empty()) {
+		FrameBuffer *requestBuffer = requestBuffers_.front();
+
+		if (!requestBuffer) {
+			/*
+			 * We want to queue an internal buffer, but none
+			 * are available. Can't do anything, quit the loop.
+			 */
+			if (availableBuffers_.empty())
+				break;
+
+			/*
+			 * We want to queue an internal buffer, and at least one
+			 * is available.
+			 */
+			requestBuffer = availableBuffers_.front();
+			availableBuffers_.pop();
+		}
+
+		requestBuffers_.pop();
+		queueToDevice(requestBuffer);
+	}
+}
+
+int Stream::queueAllBuffers()
+{
+	int ret;
+
+	if (external_)
+		return 0;
+
+	while (!availableBuffers_.empty()) {
+		ret = queueBuffer(availableBuffers_.front());
+		if (ret < 0)
+			return ret;
+
+		availableBuffers_.pop();
+	}
+
+	return 0;
+}
+
+void Stream::releaseBuffers()
+{
+	dev_->releaseBuffers();
+	clearBuffers();
+}
+
+void Stream::clearBuffers()
+{
+	availableBuffers_ = std::queue<FrameBuffer *>{};
+	requestBuffers_ = std::queue<FrameBuffer *>{};
+	internalBuffers_.clear();
+	bufferMap_.clear();
+	id_.reset();
+}
+
+int Stream::queueToDevice(FrameBuffer *buffer)
+{
+	LOG(RPISTREAM, Debug) << "Queuing buffer " << getBufferId(buffer)
+			      << " for " << name_;
+
+	int ret = dev_->queueBuffer(buffer);
+	if (ret)
+		LOG(RPISTREAM, Error) << "Failed to queue buffer for "
+				      << name_;
+	return ret;
+}
+
+} /* namespace RPi */
+
+} /* namespace libcamera */
diff --git a/src/libcamera/pipeline/rpi/common/rpi_stream.h b/src/libcamera/pipeline/rpi/common/rpi_stream.h
new file mode 100644
index 00000000..b8bd79cf
--- /dev/null
+++ b/src/libcamera/pipeline/rpi/common/rpi_stream.h
@@ -0,0 +1,185 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2020, Raspberry Pi Ltd
+ *
+ * rpi_stream.h - Raspberry Pi device stream abstraction class.
+ */
+
+#pragma once
+
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <libcamera/stream.h>
+
+#include "libcamera/internal/v4l2_videodevice.h"
+
+namespace libcamera {
+
+namespace RPi {
+
+using BufferMap = std::unordered_map<unsigned int, FrameBuffer *>;
+
+enum BufferMask {
+	MaskID			= 0x00ffff,
+	MaskStats		= 0x010000,
+	MaskEmbeddedData	= 0x020000,
+	MaskBayerData		= 0x040000,
+	MaskExternalBuffer	= 0x100000,
+};
+
+/*
+ * Device stream abstraction for either an internal or external stream.
+ * Used for both Unicam and the ISP.
+ */
+class Stream : public libcamera::Stream
+{
+public:
+	Stream()
+		: id_(BufferMask::MaskID)
+	{
+	}
+
+	Stream(const char *name, MediaEntity *dev, bool importOnly = false)
+		: external_(false), importOnly_(importOnly), name_(name),
+		  dev_(std::make_unique<V4L2VideoDevice>(dev)), id_(BufferMask::MaskID)
+	{
+	}
+
+	V4L2VideoDevice *dev() const;
+	std::string name() const;
+	bool isImporter() const;
+	void resetBuffers();
+
+	void setExternal(bool external);
+	bool isExternal() const;
+
+	void setExportedBuffers(std::vector<std::unique_ptr<FrameBuffer>> *buffers);
+	const BufferMap &getBuffers() const;
+	int getBufferId(FrameBuffer *buffer) const;
+
+	void setExternalBuffer(FrameBuffer *buffer);
+	void removeExternalBuffer(FrameBuffer *buffer);
+
+	int prepareBuffers(unsigned int count);
+	int queueBuffer(FrameBuffer *buffer);
+	void returnBuffer(FrameBuffer *buffer);
+
+	int queueAllBuffers();
+	void releaseBuffers();
+
+private:
+	class IdGenerator
+	{
+	public:
+		IdGenerator(int max)
+			: max_(max), id_(0)
+		{
+		}
+
+		int get()
+		{
+			int id;
+			if (!recycle_.empty()) {
+				id = recycle_.front();
+				recycle_.pop();
+			} else {
+				id = id_++;
+				ASSERT(id_ <= max_);
+			}
+			return id;
+		}
+
+		void release(int id)
+		{
+			recycle_.push(id);
+		}
+
+		void reset()
+		{
+			id_ = 0;
+			recycle_ = {};
+		}
+
+	private:
+		int max_;
+		int id_;
+		std::queue<int> recycle_;
+	};
+
+	void clearBuffers();
+	int queueToDevice(FrameBuffer *buffer);
+
+	/*
+	 * Indicates that this stream is active externally, i.e. the buffers
+	 * might be provided by (and returned to) the application.
+	 */
+	bool external_;
+
+	/* Indicates that this stream only imports buffers, e.g. ISP input. */
+	bool importOnly_;
+
+	/* Stream name identifier. */
+	std::string name_;
+
+	/* The actual device stream. */
+	std::unique_ptr<V4L2VideoDevice> dev_;
+
+	/* Tracks a unique id key for the bufferMap_ */
+	IdGenerator id_;
+
+	/* All frame buffers associated with this device stream. */
+	BufferMap bufferMap_;
+
+	/*
+	 * List of frame buffers that we can use if none have been provided by
+	 * the application for external streams. This is populated by the
+	 * buffers exported internally.
+	 */
+	std::queue<FrameBuffer *> availableBuffers_;
+
+	/*
+	 * List of frame buffers that are to be queued into the device from a Request.
+	 * A nullptr indicates any internal buffer can be used (from availableBuffers_),
+	 * whereas a valid pointer indicates an external buffer to be queued.
+	 *
+	 * Ordering buffers to be queued is important here as it must match the
+	 * requests coming from the application.
+	 */
+	std::queue<FrameBuffer *> requestBuffers_;
+
+	/*
+	 * This is a list of buffers exported internally. Need to keep this around
+	 * as the stream needs to maintain ownership of these buffers.
+	 */
+	std::vector<std::unique_ptr<FrameBuffer>> internalBuffers_;
+};
+
+/*
+ * The following class is just a convenient (and typesafe) array of device
+ * streams indexed with an enum class.
+ */
+template<typename E, std::size_t N>
+class Device : public std::array<class Stream, N>
+{
+private:
+	constexpr auto index(E e) const noexcept
+	{
+		return static_cast<std::underlying_type_t<E>>(e);
+	}
+public:
+	Stream &operator[](E e)
+	{
+		return std::array<class Stream, N>::operator[](index(e));
+	}
+	const Stream &operator[](E e) const
+	{
+		return std::array<class Stream, N>::operator[](index(e));
+	}
+};
+
+} /* namespace RPi */
+
+} /* namespace libcamera */