/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2019, Google Inc. * * geometry.h - Geometry-related classes */ #ifndef __LIBCAMERA_GEOMETRY_H__ #define __LIBCAMERA_GEOMETRY_H__ #include #include #include namespace libcamera { class Rectangle; class Point { public: constexpr Point() : x(0), y(0) { } constexpr Point(int xpos, int ypos) : x(xpos), y(ypos) { } int x; int y; const std::string toString() const; constexpr Point operator-() const { return { -x, -y }; } }; bool operator==(const Point &lhs, const Point &rhs); static inline bool operator!=(const Point &lhs, const Point &rhs) { return !(lhs == rhs); } class Size { public: constexpr Size() : Size(0, 0) { } constexpr Size(unsigned int w, unsigned int h) : width(w), height(h) { } unsigned int width; unsigned int height; bool isNull() const { return !width && !height; } const std::string toString() const; Size &alignDownTo(unsigned int hAlignment, unsigned int vAlignment) { width = width / hAlignment * hAlignment; height = height / vAlignment * vAlignment; return *this; } Size &alignUpTo(unsigned int hAlignment, unsigned int vAlignment) { width = (width + hAlignment - 1) / hAlignment * hAlignment; height = (height + vAlignment - 1) / vAlignment * vAlignment; return *this; } Size &boundTo(const Size &bound) { width = std::min(width, bound.width); height = std::min(height, bound.height); return *this; } Size &expandTo(const Size &expand) { width = std::max(width, expand.width); height = std::max(height, expand.height); return *this; } __nodiscard constexpr Size alignedDownTo(unsigned int hAlignment, unsigned int vAlignment) const { return { width / hAlignment * hAlignment, height / vAlignment * vAlignment }; } __nodiscard constexpr Size alignedUpTo(unsigned int hAlignment, unsigned int vAlignment) const { return { (width + hAlignment - 1) / hAlignment * hAlignment, (height + vAlignment - 1) / vAlignment * vAlignment }; } __nodiscard constexpr Size boundedTo(const Size &bound) const { return { std::min(width, bound.width), std::min(height, bound.height) }; } __nodiscard constexpr Size expandedTo(const Size &expand) const { return { std::max(width, expand.width), std::max(height, expand.height) }; } __nodiscard Size boundedToAspectRatio(const Size &ratio) const; __nodiscard Size expandedToAspectRatio(const Size &ratio) const; __nodiscard Rectangle centeredTo(const Point ¢er) const; Size operator*(float factor) const; Size operator/(float factor) const; Size &operator*=(float factor); Size &operator/=(float factor); }; bool operator==(const Size &lhs, const Size &rhs); bool operator<(const Size &lhs, const Size &rhs); static inline bool operator!=(const Size &lhs, const Size &rhs) { return !(lhs == rhs); } static inline bool operator<=(const Size &lhs, const Size &rhs) { return lhs < rhs || lhs == rhs; } static inline bool operator>(const Size &lhs, const Size &rhs) { return !(lhs <= rhs); } static inline bool operator>=(const Size &lhs, const Size &rhs) { return !(lhs < rhs); } class SizeRange { public: SizeRange() : hStep(0), vStep(0) { } SizeRange(const Size &size) : min(size), max(size), hStep(1), vStep(1) { } SizeRange(const Size &minSize, const Size &maxSize) : min(minSize), max(maxSize), hStep(1), vStep(1) { } SizeRange(const Size &minSize, const Size &maxSize, unsigned int hstep, unsigned int vstep) : min(minSize), max(maxSize), hStep(hstep), vStep(vstep) { } bool contains(const Size &size) const; std::string toString() const; Size min; Size max; unsigned int hStep; unsigned int vStep; }; bool operator==(const SizeRange &lhs, const SizeRange &rhs); static inline bool operator!=(const SizeRange &lhs, const SizeRange &rhs) { return !(lhs == rhs); } class Rectangle { public: constexpr Rectangle() : Rectangle(0, 0, 0, 0) { } constexpr Rectangle(int xpos, int ypos, const Size &size) : x(xpos), y(ypos), width(size.width), height(size.height) { } constexpr Rectangle(int xpos, int ypos, unsigned int w, unsigned int h) : x(xpos), y(ypos), width(w), height(h) { } constexpr explicit Rectangle(const Size &size) : x(0), y(0), width(size.width), height(size.height) { } int x; int y; unsigned int width; unsigned int height; bool isNull() const { return !width && !height; } const std::string toString() const; Point center() const; Size size() const { return { width, height }; } Point topLeft() const { return { x, y }; } Rectangle &scaleBy(const Size &numerator, const Size &denominator); Rectangle &translateBy(const Point &point); __nodiscard Rectangle boundedTo(const Rectangle &bound) const; __nodiscard Rectangle enclosedIn(const Rectangle &boundary) const; __nodiscard Rectangle scaledBy(const Size &numerator, const Size &denominator) const; __nodiscard Rectangle translatedBy(const Point &point) const; }; bool operator==(const Rectangle &lhs, const Rectangle &rhs); static inline bool operator!=(const Rectangle &lhs, const Rectangle &rhs) { return !(lhs == rhs); } } /* namespace libcamera */ #endif /* __LIBCAMERA_GEOMETRY_H__ */ 0 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * camera_ops.h - Android Camera HAL Operations
 */

#include "camera_ops.h"

#include <system/camera_metadata.h>

#include "camera_device.h"

using namespace libcamera;

/*
 * Translation layer between the Android Camera HAL device operations and the
 * CameraDevice.
 */

static int hal_dev_initialize(const struct camera3_device *dev,
			      const camera3_callback_ops_t *callback_ops)
{
	if (!dev)
		return -EINVAL;

	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);
	camera->setCallbacks(callback_ops);

	return 0;
}

static int hal_dev_configure_streams(const struct camera3_device *dev,
				     camera3_stream_configuration_t *stream_list)
{
	if (!dev)
		return -EINVAL;

	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);
	return camera->configureStreams(stream_list);
}

static const camera_metadata_t *
hal_dev_construct_default_request_settings(const struct camera3_device *dev,
					   int type)
{
	if (!dev)
		return nullptr;

	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);
	return camera->constructDefaultRequestSettings(type);
}

static int hal_dev_process_capture_request(const struct camera3_device *dev,
					   camera3_capture_request_t *request)
{
	if (!dev)
		return -EINVAL;

	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);
	return camera->processCaptureRequest(request);
}

static void hal_dev_dump([[maybe_unused]] const struct camera3_device *dev,
			 [[maybe_unused]] int fd)
{
}

static int hal_dev_flush(const struct camera3_device *dev)
{
	if (!dev)
		return -EINVAL;

	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);
	camera->flush();

	return 0;
}

int hal_dev_close(hw_device_t *hw_device)
{
	if (!hw_device)
		return -EINVAL;

	camera3_device_t *dev = reinterpret_cast<camera3_device_t *>(hw_device);
	CameraDevice *camera = reinterpret_cast<CameraDevice *>(dev->priv);

	camera->close();

	return 0;
}

camera3_device_ops hal_dev_ops = {
	.initialize = hal_dev_initialize,
	.configure_streams = hal_dev_configure_streams,
	.register_stream_buffers = nullptr,
	.construct_default_request_settings = hal_dev_construct_default_request_settings,
	.process_capture_request = hal_dev_process_capture_request,
	.get_metadata_vendor_tag_ops = nullptr,
	.dump = hal_dev_dump,
	.flush = hal_dev_flush,
	.reserved = { nullptr },
};