/* 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 namespace libcamera { 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; } constexpr Size alignedDownTo(unsigned int hAlignment, unsigned int vAlignment) const { return { width / hAlignment * hAlignment, height / vAlignment * vAlignment }; } constexpr Size alignedUpTo(unsigned int hAlignment, unsigned int vAlignment) const { return { (width + hAlignment - 1) / hAlignment * hAlignment, (height + vAlignment - 1) / vAlignment * vAlignment }; } constexpr Size boundedTo(const Size &bound) const { return { std::min(width, bound.width), std::min(height, bound.height) }; } constexpr Size expandedTo(const Size &expand) const { return { std::max(width, expand.width), std::max(height, expand.height) }; } }; 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) { } int x; int y; unsigned int width; unsigned int height; bool isNull() const { return !width && !height; } const std::string toString() 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__ */ id='n30' href='#n30'>30 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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * message.cpp - Messages test
 */

#include <chrono>
#include <iostream>
#include <memory>
#include <thread>

#include <libcamera/base/message.h>
#include <libcamera/base/thread.h>

#include "test.h"

using namespace std;
using namespace libcamera;

class MessageReceiver : public Object
{
public:
	enum Status {
		NoMessage,
		InvalidThread,
		MessageReceived,
	};

	MessageReceiver(Object *parent = nullptr)
		: Object(parent), status_(NoMessage)
	{
	}

	Status status() const { return status_; }
	void reset() { status_ = NoMessage; }

protected:
	void message(Message *msg)
	{
		if (msg->type() != Message::None) {
			Object::message(msg);
			return;
		}

		if (thread() != Thread::current())
			status_ = InvalidThread;
		else
			status_ = MessageReceived;
	}

private:
	Status status_;
};

class RecursiveMessageReceiver : public Object
{
public:
	RecursiveMessageReceiver()
		: child_(this), success_(false)
	{
	}

	bool success() const { return success_; }

protected:
	void message([[maybe_unused]] Message *msg)
	{
		if (msg->type() != Message::None) {
			Object::message(msg);
			return;
		}

		child_.postMessage(std::make_unique<Message>(Message::None));

		/*
		 * If the child has already received the message, something is
		 * wrong.
		 */
		if (child_.status() != MessageReceiver::NoMessage)
			return;

		Thread::current()->dispatchMessages(Message::None);

		/* The child should now have received the message. */
		if (child_.status() == MessageReceiver::MessageReceived)
			success_ = true;
	}

private:
	MessageReceiver child_;
	bool success_;
};

class SlowMessageReceiver : public Object
{
protected:
	void message(Message *msg)
	{
		if (msg->type() != Message::None) {
			Object::message(msg);
			return;
		}

		/*
		 * Don't access any member of the object here (including the
		 * vtable) as the object will be deleted by the main thread
		 * while we're sleeping.
		 */
		this_thread::sleep_for(chrono::milliseconds(100));
	}
};

class MessageTest : public Test
{
protected:
	int run()
	{
		Message::Type msgType[2] = {
			Message::registerMessageType(),
			Message::registerMessageType(),
		};

		if (msgType[0] != Message::UserMessage ||
		    msgType[1] != Message::UserMessage + 1) {
			cout << "Failed to register message types" << endl;
			return TestFail;
		}

		MessageReceiver receiver;
		receiver.moveToThread(&thread_);

		thread_.start();

		receiver.postMessage(std::make_unique<Message>(Message::None));

		this_thread::sleep_for(chrono::milliseconds(100));

		switch (receiver.status()) {
		case MessageReceiver::NoMessage:
			cout << "No message received" << endl;
			return TestFail;
		case MessageReceiver::InvalidThread:
			cout << "Message received in incorrect thread" << endl;
			return TestFail;
		default:
			break;
		}

		/*
		 * Test for races between message delivery and object deletion.
		 * Failures result in assertion errors, there is no need for
		 * explicit checks.
		 */
		SlowMessageReceiver *slowReceiver = new SlowMessageReceiver();
		slowReceiver->moveToThread(&thread_);
		slowReceiver->postMessage(std::make_unique<Message>(Message::None));

		this_thread::sleep_for(chrono::milliseconds(10));

		delete slowReceiver;

		this_thread::sleep_for(chrono::milliseconds(100));

		/*
		 * Test recursive calls to Thread::dispatchMessages(). Messages
		 * should be delivered correctly, without crashes or memory
		 * leaks. Two messages need to be posted to ensure we don't only
		 * test the simple case of a queue containing a single message.
		 */
		std::unique_ptr<RecursiveMessageReceiver> recursiveReceiver =
			std::make_unique<RecursiveMessageReceiver>();
		recursiveReceiver->moveToThread(&thread_);

		recursiveReceiver->postMessage(std::make_unique<Message>(Message::None));
		recursiveReceiver->postMessage(std::make_unique<Message>(Message::UserMessage));

		this_thread::sleep_for(chrono::milliseconds(10));

		if (!recursiveReceiver->success()) {
			cout << "Recursive message delivery failed" << endl;
			return TestFail;
		}

		return TestPass;
	}

	void cleanup()
	{
		thread_.exit(0);
		thread_.wait();
	}

private:
	Thread thread_;
};

TEST_REGISTER(MessageTest)