Manager for IPA modules. More...

Public Member Functions
	IPAManager ()
	Construct an IPAManager instance. More...

Static Public Member Functions
template<typename T >
static std::unique_ptr< T >	createIPA (PipelineHandler *pipe, uint32_t minVersion, uint32_t maxVersion)
	Create an IPA proxy that matches a given pipeline handler. More...

static const PubKey &	pubKey ()
	Retrieve the IPA module signing public key. More...

Detailed Description

Manager for IPA modules.

The IPA module manager discovers IPA modules from disk, queries and loads them, and creates IPA contexts. It supports isolation of the modules in a separate process with IPC communication and offers a unified IPAInterface view of the IPA contexts to pipeline handlers regardless of whether the modules are isolated or loaded in the same process.

Module isolation is based on the module licence. Open-source modules are loaded without isolation, while closed-source module are forcefully isolated. The isolation mechanism ensures that no code from a closed-source module is ever run in the libcamera process.

To create an IPA context, pipeline handlers call the IPAManager::createIPA() function. For a directly loaded module, the manager calls the module's ipaCreate() function directly and wraps the returned context in an IPAContextWrapper that exposes an IPAInterface.

+---------------+
|   Pipeline    |
|    Handler    |
+---------------+
        |
        v
+---------------+                   +---------------+
|      IPA      |                   |  Open Source  |
|   Interface   |                   |  IPA Module   |
| - - - - - - - |                   | - - - - - - - |
|  IPA Context  |  ipa_context_ops  |  ipa_context  |
|    Wrapper    | ----------------> |               |
+---------------+                   +---------------+

For an isolated module, the manager instantiates an IPAProxy which spawns a new process for an IPA proxy worker. The worker loads the IPA module and creates the IPA context. The IPAProxy alse exposes an IPAInterface.

+---------------+                   +---------------+
|   Pipeline    |                   | Closed Source |
|    Handler    |                   |  IPA Module   |
+---------------+                   | - - - - - - - |
        |                           |  ipa_context  |
        v                           |               |
+---------------+                   +---------------+
|      IPA      |           ipa_context_ops ^
|   Interface   |                           |
| - - - - - - - |                   +---------------+
|   IPA Proxy   |     operations    |   IPA Proxy   |
|               | ----------------> |    Worker     |
+---------------+      over IPC     +---------------+

The IPAInterface implemented by the IPAContextWrapper or IPAProxy is returned to the pipeline handler, and all interactions with the IPA context go the same interface regardless of process isolation.

In all cases the data passed to the IPAInterface member functions is serialized to Plain Old Data, either for the purpose of passing it to the IPA context plain C API, or to transmit the data to the isolated process through IPC.

Constructor & Destructor Documentation

◆ IPAManager()

libcamera::IPAManager::IPAManager ( )

Construct an IPAManager instance.

The IPAManager class is meant to only be instantiated once, by the CameraManager.

Member Function Documentation

◆ createIPA()

template<typename T >

libcamera::IPAManager::createIPA	(	PipelineHandler *	pipe,
		uint32_t	minVersion,
		uint32_t	maxVersion
	)

inlinestatic

Create an IPA proxy that matches a given pipeline handler.

Parameters

[in]	pipe	The pipeline handler that wants a matching IPA proxy
[in]	minVersion	Minimum acceptable version of IPA module
[in]	maxVersion	Maximum acceptable version of IPA module

Returns: A newly created IPA proxy, or nullptr if no matching IPA module is found or if the IPA proxy fails to initialize

◆ pubKey()

libcamera::IPAManager::pubKey ( )

inlinestatic

Retrieve the IPA module signing public key.

IPA module signature verification is normally handled internally by the IPAManager class. This function is meant to be used by utilities that need to verify signatures externally.

Returns: The IPA module signing public key

The documentation for this class was generated from the following files:

include/libcamera/internal/ipa_manager.h
src/libcamera/ipa_manager.cpp
build/src/libcamera/ipa_pub_key.cpp