libcamera/libcamera.git - libcamera official repository

diff options

Diffstat (limited to 'src/ipa/raspberrypi/controller/ccm_algorithm.h')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen@ideasonboard.com> * * Python bindings */ #include "py_main.h" #include <memory> #include <stdexcept> #include <string> #include <vector> #include <libcamera/base/log.h> #include <libcamera/libcamera.h> #include <pybind11/functional.h> #include <pybind11/pybind11.h> #include <pybind11/stl.h> #include <pybind11/stl_bind.h> #include "py_camera_manager.h" #include "py_helpers.h" namespace py = pybind11; using namespace libcamera; namespace libcamera { LOG_DEFINE_CATEGORY(Python) } /* * This is a holder class used only for the Camera class, for the sole purpose * of avoiding the compilation issue with Camera's private destructor. * * pybind11 requires a public destructor for classes held with shared_ptrs, even * in cases where the public destructor is not strictly needed. The current * understanding is that there are the following options to solve the problem: * * - Use pybind11 'smart_holder' branch. The downside is that 'smart_holder' * is not the mainline branch, and not available in distributions. * - https://github.com/pybind/pybind11/pull/2067 * - Make the Camera destructor public * - Something like the PyCameraSmartPtr here, which adds a layer, hiding the * issue. */ template<typename T> class PyCameraSmartPtr { public: using element_type = T; PyCameraSmartPtr() { } explicit PyCameraSmartPtr(T *) { throw std::runtime_error("invalid SmartPtr constructor call"); } explicit PyCameraSmartPtr(std::shared_ptr<T> p) : ptr_(p) { } T *get() const { return ptr_.get(); } operator std::shared_ptr<T>() const { return ptr_; } private: std::shared_ptr<T> ptr_; }; PYBIND11_DECLARE_HOLDER_TYPE(T, PyCameraSmartPtr<T>) /* * Note: global C++ destructors can be ran on this before the py module is * destructed. */ static std::weak_ptr<PyCameraManager> gCameraManager; void init_py_color_space(py::module &m); void init_py_controls_generated(py::module &m); void init_py_enums(py::module &m); void init_py_formats_generated(py::module &m); void init_py_geometry(py::module &m); void init_py_properties_generated(py::module &m); void init_py_transform(py::module &m); PYBIND11_MODULE(_libcamera, m) { init_py_enums(m); init_py_controls_generated(m); init_py_geometry(m); init_py_properties_generated(m); init_py_color_space(m); init_py_transform(m); /* Forward declarations */ /* * We need to declare all the classes here so that Python docstrings * can be generated correctly. * https://pybind11.readthedocs.io/en/latest/advanced/misc.html#avoiding-c-types-in-docstrings */ auto pyCameraManager = py::class_<PyCameraManager, std::shared_ptr<PyCameraManager>>(m, "CameraManager"); auto pyCamera = py::class_<Camera, PyCameraSmartPtr<Camera>>(m, "Camera"); auto pySensorConfiguration = py::class_<SensorConfiguration>(m, "SensorConfiguration"); auto pyCameraConfiguration = py::class_<CameraConfiguration>(m, "CameraConfiguration"); auto pyCameraConfigurationStatus = py::enum_<CameraConfiguration::Status>(pyCameraConfiguration, "Status"); auto pyStreamConfiguration = py::class_<StreamConfiguration>(m, "StreamConfiguration"); auto pyStreamFormats = py::class_<StreamFormats>(m, "StreamFormats"); auto pyFrameBufferAllocator = py::class_<FrameBufferAllocator>(m, "FrameBufferAllocator"); auto pyFrameBuffer = py::class_<FrameBuffer>(m, "FrameBuffer"); auto pyFrameBufferPlane = py::class_<FrameBuffer::Plane>(pyFrameBuffer, "Plane"); auto pyStream = py::class_<Stream>(m, "Stream"); auto pyControlId = py::class_<ControlId>(m, "ControlId"); auto pyControlInfo = py::class_<ControlInfo>(m, "ControlInfo"); auto pyRequest = py::class_<Request>(m, "Request"); auto pyRequestStatus = py::enum_<Request::Status>(pyRequest, "Status"); auto pyRequestReuse = py::enum_<Request::ReuseFlag>(pyRequest, "Reuse"); auto pyFrameMetadata = py::class_<FrameMetadata>(m, "FrameMetadata"); auto pyFrameMetadataStatus = py::enum_<FrameMetadata::Status>(pyFrameMetadata, "Status"); auto pyFrameMetadataPlane = py::class_<FrameMetadata::Plane>(pyFrameMetadata, "Plane"); auto pyPixelFormat = py::class_<PixelFormat>(m, "PixelFormat"); init_py_formats_generated(m); /* Global functions */ m.def("log_set_level", &logSetLevel); /* Classes */ pyCameraManager .def_static("singleton", []() { std::shared_ptr<PyCameraManager> cm = gCameraManager.lock(); if (!cm) { cm = std::make_shared<PyCameraManager>(); gCameraManager = cm; } return cm; }) .def_property_readonly_static("version", [](py::object /* self */) { return PyCameraManager::version(); }) .def("get", &PyCameraManager::get, py::keep_alive<0, 1>()) .def_property_readonly("cameras", &PyCameraManager::cameras) .def_property_readonly("event_fd", &PyCameraManager::eventFd) .def("get_ready_requests", &PyCameraManager::getReadyRequests); pyCamera .def_property_readonly("id", &Camera::id) .def("acquire", [](Camera &self) { int ret = self.acquire(); if (ret) throw std::system_error(-ret, std::generic_category(), "Failed to acquire camera"); }) .def("release", [](Camera &self) { int ret = self.release(); if (ret) throw std::system_error(-ret, std::generic_category(), "Failed to release camera"); }) .def("start", [](Camera &self, const std::unordered_map<const ControlId *, py::object> &controls) { /* \todo What happens if someone calls start() multiple times? */ auto cm = gCameraManager.lock(); ASSERT(cm); self.requestCompleted.connect(cm.get(), &PyCameraManager::handleRequestCompleted); ControlList controlList(self.controls()); for (const auto &[id, obj] : controls) { auto val = pyToControlValue(obj, id->type()); controlList.set(id->id(), val); } int ret = self.start(&controlList); if (ret) { self.requestCompleted.disconnect(); throw std::system_error(-ret, std::generic_category(), "Failed to start camera"); } }, py::arg("controls") = std::unordered_map<const ControlId *, py::object>()) .def("stop", [](Camera &self) { int ret = self.stop(); self.requestCompleted.disconnect(); if (ret) throw std::system_error(-ret, std::generic_category(), "Failed to stop camera"); }) .def("__str__", [](Camera &self) { return "<libcamera.Camera '" + self.id() + "'>"; }) /* Keep the camera alive, as StreamConfiguration contains a Stream* */ .def("generate_configuration", [](Camera &self, const std::vector<StreamRole> &roles) { return self.generateConfiguration(roles); }, py::keep_alive<0, 1>()) .def("configure", [](Camera &self, CameraConfiguration *config) { int ret = self.configure(config); if (ret) throw std::system_error(-ret, std::generic_category(), "Failed to configure camera"); }) .def("create_request", [](Camera &self, uint64_t cookie) { std::unique_ptr<Request> req = self.createRequest(cookie); if (!req) throw std::system_error(ENOMEM, std::generic_category(), "Failed to create request"); return req; }, py::arg("cookie") = 0) .def("queue_request", [](Camera &self, Request *req) { py::object py_req = py::cast(req); /* * Increase the reference count, will be dropped in * CameraManager.get_ready_requests(). */ py_req.inc_ref(); int ret = self.queueRequest(req); if (ret) { py_req.dec_ref(); throw std::system_error(-ret, std::generic_category(), "Failed to queue request"); } }) .def_property_readonly("streams", [](Camera &self) { py::set set; for (auto &s : self.streams()) { py::object py_self = py::cast(self); py::object py_s = py::cast(s); py::detail::keep_alive_impl(py_s, py_self); set.add(py_s); } return set; }) .def_property_readonly("controls", [](Camera &self) { /* Convert ControlInfoMap to std container */ std::unordered_map<const ControlId *, ControlInfo> ret; for (const auto &[k, cv] : self.controls()) ret[k] = cv; return ret; }) .def_property_readonly("properties", [](Camera &self) { /* Convert ControlList to std container */ std::unordered_map<const ControlId *, py::object> ret; for (const auto &[k, cv] : self.properties()) { const ControlId *id = properties::properties.at(k); py::object ob = controlValueToPy(cv); ret[id] = ob; } return ret; }); pySensorConfiguration .def(py::init<>()) .def_readwrite("bit_depth", &SensorConfiguration::bitDepth) .def_readwrite("analog_crop", &SensorConfiguration::analogCrop) .def_property( "binning", [](SensorConfiguration &self) { return py::make_tuple(self.binning.binX, self.binning.binY); }, [](SensorConfiguration &self, py::object value) { auto vec = value.cast<std::vector<unsigned int>>(); if (vec.size() != 2) throw std::runtime_error("binning requires iterable of 2 values"); self.binning.binX = vec[0]; self.binning.binY = vec[1]; }) .def_property( "skipping", [](SensorConfiguration &self) { return py::make_tuple(self.skipping.xOddInc, self.skipping.xEvenInc, self.skipping.yOddInc, self.skipping.yEvenInc); }, [](SensorConfiguration &self, py::object value) { auto vec = value.cast<std::vector<unsigned int>>(); if (vec.size() != 4) throw std::runtime_error("skipping requires iterable of 4 values"); self.skipping.xOddInc = vec[0]; self.skipping.xEvenInc = vec[1]; self.skipping.yOddInc = vec[2]; self.skipping.yEvenInc = vec[3]; }) .def_readwrite("output_size", &SensorConfiguration::outputSize) .def("is_valid", &SensorConfiguration::isValid); pyCameraConfiguration .def("__iter__", [](CameraConfiguration &self) { return py::make_iterator<py::return_value_policy::reference_internal>(self); }, py::keep_alive<0, 1>()) .def("__len__", [](CameraConfiguration &self) { return self.size(); }) .def("validate", &CameraConfiguration::validate) .def("at", py::overload_cast<unsigned int>(&CameraConfiguration::at), py::return_value_policy::reference_internal) .def_property_readonly("size", &CameraConfiguration::size) .def_property_readonly("empty", &CameraConfiguration::empty) .def_readwrite("sensor_config", &CameraConfiguration::sensorConfig) .def_readwrite("transform", &CameraConfiguration::transform); pyCameraConfigurationStatus .value("Valid", CameraConfiguration::Valid) .value("Adjusted", CameraConfiguration::Adjusted) .value("Invalid", CameraConfiguration::Invalid); pyStreamConfiguration


context:
space:
mode: