/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2020, Google Inc. * * delayed_controls.cpp - libcamera delayed controls test */ #include #include "libcamera/internal/delayed_controls.h" #include "libcamera/internal/device_enumerator.h" #include "libcamera/internal/media_device.h" #include "libcamera/internal/v4l2_videodevice.h" #include "test.h" using namespace std; using namespace libcamera; class DelayedControlsTest : public Test { public: DelayedControlsTest() { } protected: int init() override { enumerator_ = DeviceEnumerator::create(); if (!enumerator_) { cerr << "Failed to create device enumerator" << endl; return TestFail; } if (enumerator_->enumerate()) { cerr << "Failed to enumerate media devices" << endl; return TestFail; } DeviceMatch dm("vivid"); dm.add("vivid-000-vid-cap"); media_ = enumerator_->search(dm); if (!media_) { cerr << "vivid video device found" << endl; return TestSkip; } dev_ = V4L2VideoDevice::fromEntityName(media_.get(), "vivid-000-vid-cap"); if (dev_->open()) { cerr << "Failed to open video device" << endl; return TestFail; } const ControlInfoMap &infoMap = dev_->controls(); /* Make sure the controls we require are present. */ if (infoMap.empty()) { cerr << "Failed to enumerate controls" << endl; return TestFail; } if (infoMap.find(V4L2_CID_BRIGHTNESS) == infoMap.end() || infoMap.find(V4L2_CID_CONTRAST) == infoMap.end()) { cerr << "Missing controls" << endl; return TestFail; } return TestPass; } int singleControlNoDelay() { std::unordered_map delays = { { V4L2_CID_BRIGHTNESS, { 0, false } }, }; std::unique_ptr delayed = std::make_unique(dev_.get(), delays); ControlList ctrls; /* Reset control to value not used in test. */ ctrls.set(V4L2_CID_BRIGHTNESS, 1); dev_->setControls(&ctrls); delayed->reset(); /* Trigger the first frame start event */ delayed->applyControls(0); /* Test control without delay are set at once. */ for (unsigned int i = 1; i < 100; i++) { int32_t value = 100 + i; ctrls.set(V4L2_CID_BRIGHTNESS, value); delayed->push(ctrls); delayed->applyControls(i); ControlList result = delayed->get(i); int32_t brightness = result.get(V4L2_CID_BRIGHTNESS).get(); if (brightness != value) { cerr << "Failed single control without delay" << " frame " << i << " expected " << value << " got " << brightness << endl; return TestFail; } } return TestPass; } int singleControlWithDelay() { std::unordered_map delays = { { V4L2_CID_BRIGHTNESS, { 1, false } }, }; std::unique_ptr delayed = std::make_unique(dev_.get(), delays); ControlList ctrls; /* Reset control to value that will be first in test. */ int32_t expected = 4; ctrls.set(V4L2_CID_BRIGHTNESS, expected); dev_->setControls(&ctrls); delayed->reset(); /* Trigger the first frame start event */ delayed->applyControls(0); /* Test single control with delay. */ for (unsigned int i = 1; i < 100; i++) { int32_t value = 10 + i; ctrls.set(V4L2_CID_BRIGHTNESS, value); delayed->push(ctrls); delayed->applyControls(i); ControlList result = delayed->get(i); int32_t brightness = result.get(V4L2_CID_BRIGHTNESS).get(); if (brightness != expected) { cerr << "Failed single control with delay" << " frame " << i << " expected " << expected << " got " << brightness << endl; return TestFail; } expected = value; } return TestPass; } int dualControlsWithDelay(uint32_t startOffset) { static const unsigned int maxDelay = 2; std::unordered_map delays = { { V4L2_CID_BRIGHTNESS, { 1, false } }, { V4L2_CID_CONTRAST, { maxDelay, false } }, }; std::unique_ptr delayed = std::make_unique(dev_.get(), delays); ControlList ctrls; /* Reset control to value that will be first two frames in test. */ int32_t expected = 200; ctrls.set(V4L2_CID_BRIGHTNESS, expected); ctrls.set(V4L2_CID_CONTRAST, expected + 1); dev_->setControls(&ctrls); delayed->reset(); /* Trigger the first frame start event */ delayed->applyControls(startOffset); /* Test dual control with delay. */ for (unsigned int i = 1; i < 100; i++) { uint32_t frame = startOffset + i; int32_t value = 10 + i; ctrls.set(V4L2_CID_BRIGHTNESS, value); ctrls.set(V4L2_CID_CONTRAST, value + 1); delayed->push(ctrls); delayed->applyControls(frame); ControlList result = delayed->get(frame); int32_t brightness = result.get(V4L2_CID_BRIGHTNESS).get(); int32_t contrast = result.get(V4L2_CID_CONTRAST).get(); if (brightness != expected || contrast != expected + 1) { cerr << "Failed dual controls" << " frame " << frame << " brightness " << brightness << " contrast " << contrast << " expected " << expected << endl; return TestFail; } expected = i < maxDelay ? expected : value - 1; } return TestPass; } int dualControlsMultiQueue() { static const unsigned int maxDelay = 2; std::unordered_map delays = { { V4L2_CID_BRIGHTNESS, { 1, false } }, { V4L2_CID_CONTRAST, { maxDelay, false } } }; std::unique_ptr delayed = std::make_unique(dev_.get(), delays); ControlList ctrls; /* Reset control to value that will be first two frames in test. */ int32_t expected = 100; ctrls.set(V4L2_CID_BRIGHTNESS, expected); ctrls.set(V4L2_CID_CONTRAST, expected); dev_->setControls(&ctrls); delayed->reset(); /* Trigger the first frame start event */ delayed->applyControls(0); /* * Queue all controls before any fake frame start. Note we * can't queue up more then the delayed controls history size * which is 16. Where one spot is used by the reset control. */ for (unsigned int i = 0; i < 15; i++) { int32_t value = 10 + i; ctrls.set(V4L2_CID_BRIGHTNESS, value); ctrls.set(V4L2_CID_CONTRAST, value); delayed->push(ctrls); } /* Process all queued controls. */ for (unsigned int i = 1; i < 16; i++) { int32_t value = 10 + i - 1; delayed->applyControls(i); ControlList result = delayed->get(i); int32_t brightness = result.get(V4L2_CID_BRIGHTNESS).get(); int32_t contrast = result.get(V4L2_CID_CONTRAST).get(); if (brightness != expected || contrast != expected) { cerr << "Failed multi queue" << " frame " << i << " brightness " << brightness << " contrast " << contrast << " expected " << expected << endl; return TestFail; } expected = i < maxDelay ? expected : value - 1; } return TestPass; } int run() override { int ret; /* Test single control without delay. */ ret = singleControlNoDelay(); if (ret) return ret; /* Test single control with delay. */ ret = singleControlWithDelay(); if (ret) return ret; /* Test dual controls with different delays. */ ret = dualControlsWithDelay(0); if (ret) return ret; /* Test dual controls with non-zero sequence start. */ ret = dualControlsWithDelay(10000); if (ret) return ret; /* Test dual controls with sequence number wraparound. */ ret = dualControlsWithDelay(UINT32_MAX - 50); if (ret) return ret; /* Test control values produced faster than consumed. */ ret = dualControlsMultiQueue(); if (ret) return ret; return TestPass; } private: std::unique_ptr enumerator_; std::shared_ptr media_; std::unique_ptr dev_; }; TEST_REGISTER(DelayedControlsTest) t (C) 2019, Google Inc. * * object.cpp - Object tests */ #include <iostream> #include <libcamera/object.h> #include "message.h" #include "thread.h" #include "test.h" using namespace std; using namespace libcamera; class InstrumentedObject : public Object { public: enum Status { NoMessage, MessageReceived, }; InstrumentedObject(Object *parent = nullptr) : Object(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_;