Merge branch 'master' into next

Author: naushir

Documentation/contributing.rst

@@ -30,10 +30,34 @@ to the public. Point your IRC client to #libcamera to say hello, or use the
 
 .. _WebChat: https://webchat.oftc.net/?channels=libcamera
 
+The IRC channel is also bridged and accessible via `Matrix`_ in the #libcamera
+room:
+
+.. _Matrix: https://matrix.to/#/#libcamera:matrix.org
+
 Source Code
 -----------
 
-libcamera is in early stages of development, and no releases are available yet.
+libcamera is in active development, including investigations into what a 'good'
+API is for the implementation. We can't guarantee we have all features
+implemented, or designed correctly yet, and we have plans to make considerable
+changes to the API and ABI in our roadmap.
+
+Even so, we provide periodic 'releases' to support distributions and packaging
+teams. To support this we are currently making releases of the 0.y.z version
+scheme, loosely following semver.
+
+In the foreseeable future, the following applies:
+
+  0.y.z : Active development, but with ABI breakage detection. The 0.y
+          version will bump on an ABI/API breakage. Ongoing development will
+          increment the .z version component. Therefore, pre 1.0 'y' is a
+          close equivalent to a major release.
+
+  1.y.z : Stable API and ABI guarantees on the Major version number.
+          Following semantic versioning as documented at https://semver.org/
+
+
 The source code is available from the project's `git tree`_.
 
 .. code-block:: shell
@@ -42,17 +66,21 @@ The source code is available from the project's `git tree`_.
 
 .. _git tree: https://git.libcamera.org/libcamera/libcamera.git/
 
-A mirror is also hosted on `LinuxTV`_.
+A development mirror is also hosted on `Freedesktop`_.
+
+.. _Freedesktop: https://gitlab.freedesktop.org/camera/libcamera
+
+Freedesktop also provides our CI and `testing pipeline`_.
 
-.. _LinuxTV: https://git.linuxtv.org/libcamera.git/
+.. _testing pipeline: https://gitlab.freedesktop.org/camera/libcamera/-/pipelines
 
 Issue Tracker
 -------------
 
-Our `issue tracker`_ tracks all bugs, issues and feature requests. All issues
-are publicly visible, and you can register for an account to create new issues.
+Our `issue tracker`_ also hosted at Freedesktop tracks all bugs, issues and
+feature requests.
 
-.. _issue tracker: https://bugs.libcamera.org/
+.. _issue tracker: https://gitlab.freedesktop.org/camera/libcamera/-/issues
 
 Documentation
 -------------

Documentation/gen-doxyfile.py

@@ -12,31 +12,25 @@
 import sys
 
 
-def fill_template(template, data):
-
-    template = open(template, 'rb').read()
-    template = template.decode('utf-8')
-    template = string.Template(template)
-
-    return template.substitute(data)
-
-
 def main(argv):
 
     parser = argparse.ArgumentParser()
     parser.add_argument('-o', dest='output', metavar='file',
                         type=argparse.FileType('w', encoding='utf-8'),
                         default=sys.stdout,
                         help='Output file name (default: standard output)')
-    parser.add_argument('template', metavar='doxyfile.tmpl', type=str,
+    parser.add_argument('template', metavar='doxyfile.tmpl',
+                        type=argparse.FileType('r', encoding='utf-8'),
                         help='Doxyfile template')
     parser.add_argument('inputs', type=str, nargs='*',
                         help='Input files')
 
     args = parser.parse_args(argv[1:])
 
     inputs = [f'"{os.path.realpath(input)}"' for input in args.inputs]
-    data = fill_template(args.template, {'inputs': (' \\\n' + ' ' * 25).join(inputs)})
+    data = string.Template(args.template.read()).substitute({
+        'inputs': (' \\\n' + ' ' * 25).join(inputs),
+    })
     args.output.write(data)
 
     return 0

include/libcamera/geometry.h

@@ -108,6 +108,12 @@ class Size
 		return *this;
 	}
 
+	Size &transpose()
+	{
+		std::swap(width, height);
+		return *this;
+	}
+
 	[[nodiscard]] constexpr Size alignedDownTo(unsigned int hAlignment,
 						   unsigned int vAlignment) const
 	{

include/libcamera/internal/camera_sensor.h

@@ -73,6 +73,7 @@ class CameraSensor
 	virtual int sensorInfo(IPACameraSensorInfo *info) const = 0;
 	virtual Transform computeTransform(Orientation *orientation) const = 0;
 	virtual BayerFormat::Order bayerOrder(Transform t) const = 0;
+	virtual Orientation mountingOrientation() const = 0;
 
 	virtual const ControlInfoMap &controls() const = 0;
 	virtual ControlList getControls(Span<const uint32_t> ids) = 0;

include/libcamera/internal/converter.h

@@ -22,6 +22,7 @@
 #include <libcamera/base/signal.h>
 
 #include <libcamera/geometry.h>
+#include "libcamera/internal/v4l2_request.h"
 
 namespace libcamera {
 
@@ -46,7 +47,7 @@ class Converter
 		Up,
 	};
 
-	Converter(MediaDevice *media, Features features = Feature::None);
+	Converter(std::shared_ptr<MediaDevice> media, Features features = Feature::None);
 	virtual ~Converter();
 
 	virtual int loadConfiguration(const std::string &filename) = 0;
@@ -79,7 +80,8 @@ class Converter
 	virtual void stop() = 0;
 
 	virtual int queueBuffers(FrameBuffer *input,
-				 const std::map<const Stream *, FrameBuffer *> &outputs) = 0;
+				 const std::map<const Stream *, FrameBuffer *> &outputs,
+				 const V4L2Request *request = nullptr) = 0;
 
 	virtual int setInputCrop(const Stream *stream, Rectangle *rect) = 0;
 	virtual std::pair<Rectangle, Rectangle> inputCropBounds() = 0;
@@ -107,7 +109,7 @@ class ConverterFactoryBase
 
 	const std::vector<std::string> &compatibles() const { return compatibles_; }
 
-	static std::unique_ptr<Converter> create(MediaDevice *media);
+	static std::unique_ptr<Converter> create(std::shared_ptr<MediaDevice> media);
 	static std::vector<ConverterFactoryBase *> &factories();
 	static std::vector<std::string> names();
 
@@ -116,7 +118,8 @@ class ConverterFactoryBase
 
 	static void registerType(ConverterFactoryBase *factory);
 
-	virtual std::unique_ptr<Converter> createInstance(MediaDevice *media) const = 0;
+	virtual std::unique_ptr<Converter>
+	createInstance(std::shared_ptr<MediaDevice> media) const = 0;
 
 	std::string name_;
 	std::vector<std::string> compatibles_;
@@ -131,7 +134,7 @@ class ConverterFactory : public ConverterFactoryBase
 	{
 	}
 
-	std::unique_ptr<Converter> createInstance(MediaDevice *media) const override
+	std::unique_ptr<Converter> createInstance(std::shared_ptr<MediaDevice> media) const override
 	{
 		return std::make_unique<_Converter>(media);
 	}

include/libcamera/internal/converter/converter_dw100.h

@@ -0,0 +1,93 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2025, Ideas on Board Oy
+ *
+ * DW100 Dewarp Engine integration
+ */
+
+#pragma once
+
+#include <memory>
+#include <queue>
+
+#include <libcamera/control_ids.h>
+#include <libcamera/controls.h>
+#include <libcamera/framebuffer.h>
+
+#include "libcamera/internal/converter/converter_dw100_vertexmap.h"
+#include "libcamera/internal/converter/converter_v4l2_m2m.h"
+#include "libcamera/internal/device_enumerator.h"
+
+namespace libcamera {
+
+class MediaDevice;
+class Rectangle;
+class Stream;
+
+class ConverterDW100Module
+{
+public:
+	virtual ~ConverterDW100Module() = default;
+
+	static std::unique_ptr<ConverterDW100Module> createModule(DeviceEnumerator *enumerator);
+
+	int init(const YamlObject &params);
+
+	int configure(const StreamConfiguration &inputCfg,
+		      const std::vector<std::reference_wrapper<StreamConfiguration>>
+			      &outputCfg);
+	bool isConfigured(const Stream *stream) const;
+
+	Size adjustInputSize(const PixelFormat &pixFmt, const Size &size,
+			     Converter::Alignment align = Converter::Alignment::Down);
+	Size adjustOutputSize(const PixelFormat &pixFmt, const Size &size,
+			      Converter::Alignment align = Converter::Alignment::Down);
+
+	int exportBuffers(const Stream *stream, unsigned int count,
+			  std::vector<std::unique_ptr<FrameBuffer>> *buffers);
+	int validateOutput(StreamConfiguration *cfg, bool *adjusted,
+			   Converter::Alignment align = Converter::Alignment::Down);
+	int queueBuffers(FrameBuffer *input,
+			 const std::map<const Stream *, FrameBuffer *> &outputs);
+
+	int start();
+	void stop();
+
+	void updateControlInfos(const Stream *stream, ControlInfoMap::Map &infos);
+	void setControls(const Stream *stream, const ControlList &controls);
+	void populateMetadata(const Stream *stream, ControlList &meta);
+
+	void setSensorCrop(const Rectangle &rect);
+	void setTransform(const Stream *stream, const Transform &transform);
+
+	Signal<FrameBuffer *> inputBufferReady;
+	Signal<FrameBuffer *> outputBufferReady;
+
+private:
+	ConverterDW100Module(std::shared_ptr<MediaDevice> media);
+
+	int applyControls(const Stream *stream, const V4L2Request *request);
+	void reinitRequest(V4L2Request *request);
+
+	struct DewarpParms {
+		Matrix<double, 3, 3> cm;
+		std::vector<double> coeffs;
+	};
+
+	struct VertexMapInfo {
+		Dw100VertexMap map;
+		bool update;
+	};
+
+	std::map<const Stream *, VertexMapInfo> vertexMaps_;
+	std::optional<DewarpParms> dewarpParams_;
+	unsigned int inputBufferCount_;
+	V4L2M2MConverter converter_;
+	Rectangle sensorCrop_;
+	bool running_;
+
+	std::vector<std::unique_ptr<V4L2Request>> requests_;
+	std::queue<V4L2Request *> availableRequests_;
+};
+
+} /* namespace libcamera */

include/libcamera/internal/converter/converter_dw100_vertexmap.h

@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2025, Ideas on Board Oy
+ *
+ * DW100 vertex map interface
+ */
+
+#pragma once
+
+#include <assert.h>
+#include <cmath>
+#include <stdint.h>
+#include <vector>
+
+#include <libcamera/base/span.h>
+
+#include <libcamera/geometry.h>
+#include <libcamera/transform.h>
+
+#include "libcamera/internal/matrix.h"
+#include "libcamera/internal/vector.h"
+
+namespace libcamera {
+
+class Dw100VertexMap
+{
+public:
+	enum ScaleMode {
+		Fill = 0,
+		Crop = 1,
+	};
+
+	void applyLimits();
+	void setInputSize(const Size &size)
+	{
+		inputSize_ = size;
+		scalerCrop_ = Rectangle(size);
+	}
+
+	void setSensorCrop(const Rectangle &rect) { sensorCrop_ = rect; }
+
+	void setScalerCrop(const Rectangle &rect) { scalerCrop_ = rect; }
+	const Rectangle &effectiveScalerCrop() const { return effectiveScalerCrop_; }
+
+	void setOutputSize(const Size &size) { outputSize_ = size; }
+	const Size &outputSize() const { return outputSize_; }
+
+	void setTransform(const Transform &transform) { transform_ = transform; }
+	const Transform &transform() const { return transform_; }
+
+	void setScale(const float scale) { scale_ = scale; }
+	float effectiveScale() const { return (effectiveScaleX_ + effectiveScaleY_) * 0.5; }
+
+	void setRotation(const float rotation) { rotation_ = rotation; }
+	float rotation() const { return rotation_; }
+
+	void setOffset(const Point &offset) { offset_ = offset; }
+	const Point &effectiveOffset() const { return effectiveOffset_; }
+
+	void setMode(const ScaleMode mode) { mode_ = mode; }
+	ScaleMode mode() const { return mode_; }
+
+	int setDewarpParams(const Matrix<double, 3, 3> &cm, const Span<const double> &coeffs);
+	bool dewarpParamsValid() { return dewarpParamsValid_; }
+
+	void setLensDewarpEnable(bool enable) { lensDewarpEnable_ = enable; }
+	bool lensDewarpEnable() { return lensDewarpEnable_; }
+
+	std::vector<uint32_t> getVertexMap();
+
+private:
+	Vector<double, 2> dewarpPoint(const Vector<double, 2> &p);
+
+	Rectangle scalerCrop_;
+	Rectangle sensorCrop_;
+	Transform transform_ = Transform::Identity;
+	Size inputSize_;
+	Size outputSize_;
+	Point offset_;
+	double scale_ = 1.0;
+	double rotation_ = 0.0;
+	ScaleMode mode_ = Fill;
+	double effectiveScaleX_;
+	double effectiveScaleY_;
+	Point effectiveOffset_;
+	Rectangle effectiveScalerCrop_;
+
+	Matrix<double, 3, 3> dewarpM_ = Matrix<double, 3, 3>::identity();
+	std::array<double, 12> dewarpCoeffs_;
+	bool lensDewarpEnable_ = true;
+	bool dewarpParamsValid_ = false;
+};
+
+} /* namespace libcamera */