diff options
Diffstat (limited to 'ipu3.cpp')
| -rw-r--r-- | ipu3.cpp | 241 |
1 files changed, 241 insertions, 0 deletions
diff --git a/ipu3.cpp b/ipu3.cpp new file mode 100644 index 0000000..827a980 --- /dev/null +++ b/ipu3.cpp @@ -0,0 +1,241 @@ +/* SPDX-License-Identifier: Apache-2.0 */ +/* + * Copyright (C) 2020, Google Inc. + * + * ipu3.cpp - IPU3 Image Processing Algorithms + */ + +#include <stdint.h> +#include <sys/mman.h> + +#include <linux/intel-ipu3.h> +#include <linux/v4l2-controls.h> + +#include <libcamera/buffer.h> +#include <libcamera/control_ids.h> +#include <libcamera/ipa/ipa_interface.h> +#include <libcamera/ipa/ipa_module_info.h> +#include <libcamera/ipa/ipu3_ipa_interface.h> +#include <libcamera/request.h> + +#include <libcamera/base/log.h> + +#include "libcamera-helpers/mapped_buffer.h" + +namespace libcamera { + +LOG_DEFINE_CATEGORY(IPAIPU3) + +namespace ipa::ipu3 { + +class IPAIPU3 : public IPAIPU3Interface +{ +public: + int init([[maybe_unused]] const IPASettings &settings) override + { + return 0; + } + int start() override; + void stop() override {} + + int configure(const IPAConfigInfo &configInfo) override; + + void mapBuffers(const std::vector<IPABuffer> &buffers) override; + void unmapBuffers(const std::vector<unsigned int> &ids) override; + void processEvent(const IPU3Event &event) override; + +private: + void processControls(unsigned int frame, const ControlList &controls); + void fillParams(unsigned int frame, ipu3_uapi_params *params); + void parseStatistics(unsigned int frame, + int64_t frameTimestamp, + const ipu3_uapi_stats_3a *stats); + + void setControls(unsigned int frame); + + std::map<unsigned int, MappedFrameBuffer> buffers_; + + ControlInfoMap ctrls_; + + IPACameraSensorInfo sensorInfo_; + + /* Camera sensor controls. */ + uint32_t exposure_; + uint32_t minExposure_; + uint32_t maxExposure_; + uint32_t gain_; + uint32_t minGain_; + uint32_t maxGain_; +}; + +int IPAIPU3::start() +{ + setControls(0); + + return 0; +} + +int IPAIPU3::configure(const IPAConfigInfo &configInfo) +{ + if (configInfo.entityControls.empty()) { + LOG(IPAIPU3, Error) << "No controls provided"; + return -ENODATA; + } + + sensorInfo_ = configInfo.sensorInfo; + + ctrls_ = configInfo.entityControls.at(0); + + const auto itExp = ctrls_.find(V4L2_CID_EXPOSURE); + if (itExp == ctrls_.end()) { + LOG(IPAIPU3, Error) << "Can't find exposure control"; + return -EINVAL; + } + + const auto itGain = ctrls_.find(V4L2_CID_ANALOGUE_GAIN); + if (itGain == ctrls_.end()) { + LOG(IPAIPU3, Error) << "Can't find gain control"; + return -EINVAL; + } + + minExposure_ = std::max(itExp->second.min().get<int32_t>(), 1); + maxExposure_ = itExp->second.max().get<int32_t>(); + exposure_ = maxExposure_; + + minGain_ = std::max(itGain->second.min().get<int32_t>(), 1); + maxGain_ = itGain->second.max().get<int32_t>(); + gain_ = maxGain_; + + return 0; +} + +void IPAIPU3::mapBuffers(const std::vector<IPABuffer> &buffers) +{ + for (const IPABuffer &buffer : buffers) { + const FrameBuffer fb(buffer.planes); + buffers_.emplace(buffer.id, + MappedFrameBuffer(&fb, PROT_READ | PROT_WRITE)); + } +} + +void IPAIPU3::unmapBuffers(const std::vector<unsigned int> &ids) +{ + for (unsigned int id : ids) { + auto it = buffers_.find(id); + if (it == buffers_.end()) + continue; + + buffers_.erase(it); + } +} + +void IPAIPU3::processEvent(const IPU3Event &event) +{ + switch (event.op) { + case EventProcessControls: { + processControls(event.frame, event.controls); + break; + } + case EventStatReady: { + auto it = buffers_.find(event.bufferId); + if (it == buffers_.end()) { + LOG(IPAIPU3, Error) << "Could not find stats buffer!"; + return; + } + + Span<uint8_t> mem = it->second.maps()[0]; + const ipu3_uapi_stats_3a *stats = + reinterpret_cast<ipu3_uapi_stats_3a *>(mem.data()); + + parseStatistics(event.frame, event.frameTimestamp, stats); + break; + } + case EventFillParams: { + auto it = buffers_.find(event.bufferId); + if (it == buffers_.end()) { + LOG(IPAIPU3, Error) << "Could not find param buffer!"; + return; + } + + Span<uint8_t> mem = it->second.maps()[0]; + ipu3_uapi_params *params = + reinterpret_cast<ipu3_uapi_params *>(mem.data()); + + fillParams(event.frame, params); + break; + } + default: + LOG(IPAIPU3, Error) << "Unknown event " << event.op; + break; + } +} + +void IPAIPU3::processControls([[maybe_unused]] unsigned int frame, + [[maybe_unused]] const ControlList &controls) +{ + /* \todo Start processing for 'frame' based on 'controls'. */ +} + +void IPAIPU3::fillParams(unsigned int frame, ipu3_uapi_params *params) +{ + /* Prepare parameters buffer. */ + memset(params, 0, sizeof(*params)); + + /* \todo Fill in parameters buffer. */ + + IPU3Action op; + op.op = ActionParamFilled; + + queueFrameAction.emit(frame, op); +} + +void IPAIPU3::parseStatistics(unsigned int frame, + [[maybe_unused]] int64_t frameTimestamp, + [[maybe_unused]] const ipu3_uapi_stats_3a *stats) +{ + ControlList ctrls(controls::controls); + + /* \todo React to statistics and update internal state machine. */ + /* \todo Add meta-data information to ctrls. */ + + IPU3Action op; + op.op = ActionMetadataReady; + op.controls = ctrls; + + queueFrameAction.emit(frame, op); +} + +void IPAIPU3::setControls(unsigned int frame) +{ + IPU3Action op; + op.op = ActionSetSensorControls; + + ControlList ctrls(ctrls_); + ctrls.set(V4L2_CID_EXPOSURE, static_cast<int32_t>(exposure_)); + ctrls.set(V4L2_CID_ANALOGUE_GAIN, static_cast<int32_t>(gain_)); + op.controls = ctrls; + + queueFrameAction.emit(frame, op); +} + +} /* namespace ipa::ipu3 */ + +/* + * External IPA module interface + */ + +extern "C" { +const struct IPAModuleInfo ipaModuleInfo = { + IPA_MODULE_API_VERSION, + 1, + "PipelineHandlerIPU3", + "ipu3", +}; + +IPAInterface *ipaCreate() +{ + return new ipa::ipu3::IPAIPU3(); +} +} + +} /* namespace libcamera */ |