Tomi ValkeinenandLaurent Pinchart
bf3dbaece9
Blocking wait can be easily implemented on top in Python, so rather than supporting only blocking reads, or supporting both non-blocking and blocking reads, let's support only non-blocking reads. Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
132 lines
2.6 KiB
C++
132 lines
2.6 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>
|
|
*/
|
|
|
|
#include "py_camera_manager.h"
|
|
|
|
#include <errno.h>
|
|
#include <memory>
|
|
#include <sys/eventfd.h>
|
|
#include <system_error>
|
|
#include <unistd.h>
|
|
#include <vector>
|
|
|
|
#include "py_main.h"
|
|
|
|
namespace py = pybind11;
|
|
|
|
using namespace libcamera;
|
|
|
|
PyCameraManager::PyCameraManager()
|
|
{
|
|
LOG(Python, Debug) << "PyCameraManager()";
|
|
|
|
cameraManager_ = std::make_unique<CameraManager>();
|
|
|
|
int fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
|
|
if (fd == -1)
|
|
throw std::system_error(errno, std::generic_category(),
|
|
"Failed to create eventfd");
|
|
|
|
eventFd_ = UniqueFD(fd);
|
|
|
|
int ret = cameraManager_->start();
|
|
if (ret)
|
|
throw std::system_error(-ret, std::generic_category(),
|
|
"Failed to start CameraManager");
|
|
}
|
|
|
|
PyCameraManager::~PyCameraManager()
|
|
{
|
|
LOG(Python, Debug) << "~PyCameraManager()";
|
|
}
|
|
|
|
py::list PyCameraManager::cameras()
|
|
{
|
|
/*
|
|
* Create a list of Cameras, where each camera has a keep-alive to
|
|
* CameraManager.
|
|
*/
|
|
py::list l;
|
|
|
|
for (auto &camera : cameraManager_->cameras()) {
|
|
py::object py_cm = py::cast(this);
|
|
py::object py_cam = py::cast(camera);
|
|
py::detail::keep_alive_impl(py_cam, py_cm);
|
|
l.append(py_cam);
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
std::vector<py::object> PyCameraManager::getReadyRequests()
|
|
{
|
|
int ret = readFd();
|
|
|
|
if (ret == -EAGAIN)
|
|
return std::vector<py::object>();
|
|
|
|
if (ret != 0)
|
|
throw std::system_error(-ret, std::generic_category());
|
|
|
|
std::vector<py::object> py_reqs;
|
|
|
|
for (Request *request : getCompletedRequests()) {
|
|
py::object o = py::cast(request);
|
|
/* Decrease the ref increased in Camera.queue_request() */
|
|
o.dec_ref();
|
|
py_reqs.push_back(o);
|
|
}
|
|
|
|
return py_reqs;
|
|
}
|
|
|
|
/* Note: Called from another thread */
|
|
void PyCameraManager::handleRequestCompleted(Request *req)
|
|
{
|
|
pushRequest(req);
|
|
writeFd();
|
|
}
|
|
|
|
void PyCameraManager::writeFd()
|
|
{
|
|
uint64_t v = 1;
|
|
|
|
size_t s = write(eventFd_.get(), &v, 8);
|
|
/*
|
|
* We should never fail, and have no simple means to manage the error,
|
|
* so let's log a fatal error.
|
|
*/
|
|
if (s != 8)
|
|
LOG(Python, Fatal) << "Unable to write to eventfd";
|
|
}
|
|
|
|
int PyCameraManager::readFd()
|
|
{
|
|
uint8_t buf[8];
|
|
|
|
ssize_t ret = read(eventFd_.get(), buf, 8);
|
|
|
|
if (ret == 8)
|
|
return 0;
|
|
else if (ret < 0)
|
|
return -errno;
|
|
else
|
|
return -EIO;
|
|
}
|
|
|
|
void PyCameraManager::pushRequest(Request *req)
|
|
{
|
|
MutexLocker guard(completedRequestsMutex_);
|
|
completedRequests_.push_back(req);
|
|
}
|
|
|
|
std::vector<Request *> PyCameraManager::getCompletedRequests()
|
|
{
|
|
std::vector<Request *> v;
|
|
MutexLocker guard(completedRequestsMutex_);
|
|
swap(v, completedRequests_);
|
|
return v;
|
|
}
|