Documentation/lens_driver_requirements.rst


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

.. SPDX-License-Identifier: CC-BY-SA-4.0

.. _lens-driver-requirements:

Lens Driver Requirements
========================

libcamera handles lens devices in the CameraLens class and defines
a consistent interface through its API towards other library components.

The CameraLens class uses the V4L2 subdev kernel API to interface with the
camera lens through a sub-device exposed to userspace by the lens driver.

In order for libcamera to be fully operational and provide all the required
information to interface with the camera lens to applications and pipeline
handlers, a set of mandatory features the driver has to support has been defined.

Mandatory Requirements
----------------------

The lens driver is assumed to be fully compliant with the V4L2 specification.

The lens driver shall support the following V4L2 controls:

* `V4L2_CID_FOCUS_ABSOLUTE`_

.. _V4L2_CID_FOCUS_ABSOLUTE: https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/ext-ctrls-camera.html
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * libcamera V4L2 device format handling test
 */

#include <iostream>
#include <limits.h>

#include <libcamera/base/utils.h>

#include "libcamera/internal/v4l2_videodevice.h"

#include "v4l2_videodevice_test.h"

using namespace std;
using namespace libcamera;

class Format : public V4L2VideoDeviceTest
{
public:
	Format()
		: V4L2VideoDeviceTest("vimc", "Raw Capture 0") {}
protected:
	int run()
	{
		V4L2DeviceFormat format = {};

		int ret = capture_->getFormat(&format);
		if (ret) {
			cerr << "Failed to get format" << endl;
			return TestFail;
		}

		format.size = { UINT_MAX, UINT_MAX };
		ret = capture_->setFormat(&format);
		if (ret) {
			cerr << "Failed to set format: image resolution is invalid: "
			     << "(UINT_MAX x UINT_MAX) but setFormat() should not fail."
			     << endl;
			return TestFail;
		}

		if (format.size.width == UINT_MAX ||
		    format.size.height == UINT_MAX) {
			cerr << "Failed to update image format = (UINT_MAX x UINT_MAX)"
			     << endl;
			return TestFail;
		}

		std::vector<std::pair<uint32_t, const char *>> formats{
			{ V4L2_PIX_FMT_YUYV, "YUYV" },
			{ 0, "<INVALID>" },
			{ v4l2_fourcc(0, 1, 2, 3), "...." },
			{ V4L2_PIX_FMT_Y16_BE, "Y16 -BE" }
		};

		for (const auto &fmt : formats) {
			if (V4L2PixelFormat(fmt.first).toString() != fmt.second) {
				cerr << "Failed to convert V4L2PixelFormat"
				     << utils::hex(fmt.first) << "to string"
				     << endl;
				return TestFail;
			}
		}

		if (V4L2PixelFormat().toString() != "<INVALID>") {
			cerr << "Failed to convert default V4L2PixelFormat to string"
			     << endl;
			return TestFail;
		}

		return TestPass;
	}
};

TEST_REGISTER(Format)