summaryrefslogtreecommitdiff
path: root/src/ipa/raspberrypi/controller/algorithm.cpp
blob: 6d91ee292bd198702a3d47807d43f8b3ccd6ee12 (plain)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/* SPDX-License-Identifier: BSD-2-Clause */
/*
 * Copyright (C) 2019, Raspberry Pi Ltd
 *
 * algorithm.cpp - ISP control algorithms
 */

#include "algorithm.h"

using namespace RPiController;

int Algorithm::read([[maybe_unused]] const libcamera::YamlObject &params)
{
	return 0;
}

void Algorithm::initialise()
{
}

void Algorithm::switchMode([[maybe_unused]] CameraMode const &cameraMode,
			   [[maybe_unused]] Metadata *metadata)
{
}

void Algorithm::prepare([[maybe_unused]] Metadata *imageMetadata)
{
}

void Algorithm::process([[maybe_unused]] StatisticsPtr &stats,
			[[maybe_unused]] Metadata *imageMetadata)
{
}

/* For registering algorithms with the system: */

static std::map<std::string, AlgoCreateFunc> algorithms;
std::map<std::string, AlgoCreateFunc> const &RPiController::getAlgorithms()
{
	return algorithms;
}

RegisterAlgorithm::RegisterAlgorithm(char const *name,
				     AlgoCreateFunc createFunc)
{
	algorithms[std::string(name)] = createFunc;
}
>(parent), status_(NoMessage) { } Status status() const { return status_; } void reset() { status_ = NoMessage; } protected: void message(Message *msg) override { if (msg->type() == Message::ThreadMoveMessage) status_ = MessageReceived; Object::message(msg); } private: Status status_; }; class ObjectTest : public Test { protected: int init() { /* * Create a hierarchy of objects: * A -> B -> C * \->D * E */ a_ = new InstrumentedObject(); b_ = new InstrumentedObject(a_); c_ = new InstrumentedObject(b_); d_ = new InstrumentedObject(a_); e_ = new InstrumentedObject(); f_ = nullptr; return TestPass; } int run() { /* Verify the parent-child relationships. */ if (a_->parent() != nullptr || b_->parent() != a_ || c_->parent() != b_ || d_->parent() != a_ || e_->parent() != nullptr) { cout << "Incorrect parent-child relationships" << endl; return TestFail; } /* * Verify that moving an object with no parent to a different * thread succeeds. */ e_->moveToThread(&thread_); if (e_->thread() != &thread_ || e_->thread() == Thread::current()) { cout << "Failed to move object to thread" << endl; return TestFail; } /* * Verify that moving an object with a parent to a different * thread fails. This results in an undefined behaviour, the * test thus depends on the internal implementation returning * without performing any change. */ b_->moveToThread(&thread_); if (b_->thread() != Thread::current()) { cout << "Moving object with parent to thread shouldn't succeed" << endl; return TestFail; } /* * Verify that moving an object with children to a different * thread moves all the children. */ a_->moveToThread(&thread_); if (a_->thread() != &thread_ || b_->thread() != &thread_ || c_->thread() != &thread_ || d_->thread() != &thread_) { cout << "Failed to move children to thread" << endl; return TestFail; } /* Verify that objects are bound to the thread of their parent. */ f_ = new InstrumentedObject(d_); if (f_->thread() != &thread_) { cout << "Failed to bind child to parent thread" << endl; return TestFail; } /* Verify that objects receive a ThreadMoveMessage when moved. */ if (a_->status() != InstrumentedObject::MessageReceived || b_->status() != InstrumentedObject::MessageReceived || c_->status() != InstrumentedObject::MessageReceived || d_->status() != InstrumentedObject::MessageReceived || e_->status() != InstrumentedObject::MessageReceived) { cout << "Moving object didn't deliver ThreadMoveMessage" << endl; return TestFail; } return TestPass; } void cleanup() { delete a_; delete b_; delete c_; delete d_; delete e_; delete f_; } private: InstrumentedObject *a_; InstrumentedObject *b_; InstrumentedObject *c_; InstrumentedObject *d_; InstrumentedObject *e_; InstrumentedObject *f_; Thread thread_; }; TEST_REGISTER(ObjectTest)