.. SPDX-License-Identifier: CC-BY-SA-4.0 IPU3 IPA Architecture Design and Overview ========================================= The IPU3 IPA is built as a modular and extensible framework with an upper layer to manage the interactions with the pipeline handler, and the image processing algorithms split to compartmentalise the processing required for each processing block, making use of the fixed-function accelerators provided by the ImgU ISP. The core IPU3 class is responsible for initialisation and construction of the algorithm components, processing controls set by the requests from applications, and managing events from the pipeline handler. :: ┌───────────────────────────────────────────┐ │ IPU3 Pipeline Handler │ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ │ │ │ │ │ │ │ │ Sensor ├───►│ CIO2 ├───►│ ImgU ├──► │ │ │ │ │ │ │ │ │ └────────┘ └────────┘ └─▲────┬─┘ │ P: Parameter Buffer │ │P │ │ S: Statistics Buffer │ │ │S │ └─┬───┬───┬──────┬────┬────┬────┬─┴────▼─┬──┘ 1: init() │ │ │ │ ▲ │ ▲ │ ▲ │ ▲ │ 2: configure() │1 │2 │3 │4│ │4│ │4│ │4│ │5 3: mapBuffers(), start() │ │ │ │ │ │ │ │ │ │ │ │ 4: (▼) queueRequest(), fillParamsBuffer(), processStatsBuffer() ▼ ▼ ▼ ▼ │ ▼ │ ▼ │ ▼ │ ▼ (▲) setSensorControls, paramsBufferReady, metadataReady Signals ┌──────────────────┴────┴────┴────┴─────────┐ 5: stop(), unmapBuffers() │ IPU3 IPA │ │ ┌───────────────────────┐ │ │ ┌───────────┐ │ Algorithms │ │ │ │IPAContext │ │ ┌─────────┐ │ │ │ │ ┌───────┐ │ │ │ ... │ │ │ │ │ │ │ │ │ ┌─┴───────┐ │ │ │ │ │ │ SC │ │ │ │ Tonemap ├─┘ │ │ │ │ │ │ ◄───► ┌─┴───────┐ │ │ │ │ │ ├───────┤ │ │ │ AWB ├─┘ │ │ │ │ │ │ │ │ ┌─┴───────┐ │ │ │ │ │ │ FC │ │ │ │ AGC ├─┘ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └───────┘ │ │ └─────────┘ │ │ │ └───────────┘ └───────────────────────┘ │ └───────────────────────────────────────────┘ SC: IPASessionConfiguration FC: IPAFrameContext(s) The IPA instance is constructed and initialised at the point a Camera is created by the IPU3 pipeline handler. The initialisation call provides details about which camera sensor is being used, and the controls that it has available, along with their default values and ranges. Buffers ~~~~~~~ The IPA will have Parameter and Statistics buffers shared with it from the IPU3 Pipeline handler. These buffers will be passed to the IPA using the ``mapBuffers()`` call before the ``start()`` operation occurs./* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ #ifndef _LINUX_UDMABUF_H #define _LINUX_UDMABUF_H #include <linux/types.h> #include <linux/ioctl.h> #define UDMABUF_FLAGS_CLOEXEC 0x01 struct udmabuf_create { __u32 memfd; __u32 flags; __u64 offset; __u64 size; }; struct udmabuf_create_item { __u32 memfd; __u32 __pad; __u64 offset; __u64 size; }; struct udmabuf_create_list { __u32 flags; __u32 count; struct udmabuf_create_item list[]; }; #define UDMABUF_CREATE _IOW('u', 0x42, struct udmabuf_create) #define UDMABUF_CREATE_LIST _IOW('u', 0x43, struct udmabuf_create_list) #endif /* _LINUX_UDMABUF_H */ ~ When configured, the IPA is notified by the pipeline handler of the Camera ``start()`` event, after which incoming requests will be queued for processing, requiring a parameter buffer (``ipu3_uapi_params``) to be populated for the ImgU. This is given to the IPA through ``fillParamsBuffer()``, and then passed directly to each algorithm through the ``prepare()`` call allowing the ISP configuration to be updated for the needs of each component that the algorithm is responsible for. The algorithm should set the use flag (``ipu3_uapi_flags``) for any structure that it modifies, and it should take care to ensure that any structure set by a use flag is fully initialised to suitable values. The parameter buffer is returned to the pipeline handler through the ``paramsBufferReady`` signal, and from there queued to the ImgU along with a raw frame captured with the CIO2. Post-frame completion ~~~~~~~~~~~~~~~~~~~~~ When the capture of an image is completed, and successfully processed through the ImgU, the generated statistics buffer (``ipu3_uapi_stats_3a``) is given to the IPA through ``processStatsBuffer()``. This provides the IPA with an opportunity to examine the results of the ISP and run the calculations required by each algorithm on the new data. The algorithms may require context from the operations of other algorithms, for example, the AWB might choose to use a scene brightness determined by the AGC. It is important that the algorithms are ordered to ensure that required results are determined before they are needed. The ordering of the algorithm processing is determined by their placement in the ``IPU3::algorithms_`` ordered list. Finally, the IPA metadata for the completed frame is returned back via the ``metadataReady`` signal. Sensor Controls ~~~~~~~~~~~~~~~ The AutoExposure and AutoGain (AGC) algorithm differs slightly from the others as it requires operating directly on the sensor, as opposed to through the ImgU ISP. To support this, there is a ``setSensorControls`` signal to allow the IPA to request controls to be set on the camera sensor through the pipeline handler.