C++ enhancement and processor control

C++ wrapper 0.24.0, core 0.24.0, C++11 or newer. Include aic.hpp and link the matching wrapper/native libraries. Start with the C++ integration guide. All names below are in namespace aic. Check Result and error handling before extracting a factory result. Ordinary C++ allocation or string operations can still throw; SDK status failures use the declared return values.

`aic::Processor`

Owns one native handle. Its destructor releases that handle; do not destroy or move the object while another thread uses it. Construction/destruction can allocate or block, so keep them outside the audio callback. The default constructor and raw-handle constructor are private: use the documented factory.

Member	Contract
`~Processor()`	Releases the native handle if non-null.
`Processor(Processor&& other) noexcept`	Transfers the handle and clears the source. Do not call processing/getter methods on the moved-from object.
`Processor& operator=(Processor&& other) noexcept`	Releases the destination’s old handle, transfers ownership and clears the source. Self-move is guarded; returns `*this`.
`Processor(const Processor&) = delete`	Copy construction is unavailable.
`Processor& operator=(const Processor&) = delete`	Copy assignment is unavailable.

`aic::Processor::create`

static Result<Processor> create(const Model& model, const std::string& license_key,
                              const OtelConfig* otel_config = nullptr);

Creates an owned Processor using an enhancement or bypass model and the null-terminated representation of license_key (SDK key or supported bearer token). The object retains model data; no ownership of the Model wrapper is transferred. otel_config is optional and is copied during creation. Returns a checked result; errors include ModelTypeUnsupported, license errors and InternalError. Construction does not initialize audio configuration. Keep it outside the audio callback.

`aic::Processor::initialize`

ErrorCode initialize(uint32_t sample_rate, size_t block_size, bool variable_block_size);

Initializes or reinitializes the object. sample_rate is the host rate in Hz (8,000–192,000); block_size is a positive mono sample count. With variable_block_size=false, input must match exactly; with true, it is the maximum per call. All three arguments are required: there is no config-object overload. Returns Success or AudioConfigUnsupported (or NullPointer for an invalid underlying handle). Failure leaves the object uninitialized. Initialization resets state and allocates; serialize it with processing.

`aic::Processor::process`

ErrorCode process(float* audio, size_t audio_len);

Processes audio_len mono float32 samples in audio in place. The writable buffer remains caller-owned and must stay valid until the call returns. Use normalized samples, nominally -1.0 to 1.0. Returns Success, NullPointer, NotInitialized, AudioConfigMismatch or ProcessingNotAllowed (and internal errors). On processing denial, buffering or delayed output may already have changed; error output is not enhanced audio. Keep one instance per stream and serialize its processing calls.

`aic::Processor::terminate_session`

ErrorCode terminate_session();

Requests asynchronous session termination and returns Success (or NullPointer for an invalid underlying handle). Processing may continue until the request is handled. It is a no-op for a credential with no telemetry session. The call neither destroys the object nor proves backend acknowledgment. Stop application processing explicitly, then allow normal destruction. On native targets, terminating the final active session may wait for the shared telemetry tasks to finish. Call it outside the audio callback.

`aic::Processor::create_context`

Result<ProcessorContext> create_context() const;

Creates a separately owned control object with shared state. Check the result before extracting it. The context can outlive its source object, but it cannot process audio after that object is destroyed. Errors include NullPointer. Context creation allocates.

`aic::ProcessorContext`

Member	Contract
`~ProcessorContext()`	Releases the native handle if non-null.
`ProcessorContext(ProcessorContext&& other) noexcept`	Transfers the handle and clears the source. Do not call processing/getter methods on the moved-from object.
`ProcessorContext& operator=(ProcessorContext&& other) noexcept`	Releases the destination’s old handle, transfers ownership and clears the source. Self-move is guarded; returns `*this`.
`ProcessorContext(const ProcessorContext&) = delete`	Copy construction is unavailable.
`ProcessorContext& operator=(const ProcessorContext&) = delete`	Copy assignment is unavailable.

Context control reads, parameter updates and reset requests use shared state and can run alongside processing. Keep handles alive through all concurrent calls. Credential updates are control-thread operations; destruction is never concurrent-safe.

`aic::ProcessorContext::reset`

ErrorCode reset() const;

Requests stream-buffer/model reset for the next processing call. Audio configuration and parameters remain in place. Returns Success or NullPointer. Coordinate the stream boundary if you require a precise reset position.

`aic::ProcessorContext::set_parameter`

ErrorCode set_parameter(ProcessorParameter parameter, float value) const;

Sets a declared ProcessorParameter to value. Returns Success, NullPointer or ParameterOutOfRange; NaN is out of range. The parameter table below defines units, defaults and accepted ranges.

`aic::ProcessorContext::get_parameter`

float get_parameter(ProcessorParameter parameter) const;

Returns the stored value of a declared parameter. The wrapper asserts C success, rather than returning a Result. A C failure leaves the initialized fallback at zero if assertions are disabled. Do not use invalid enum values or a moved-from context.

`aic::ProcessorContext::get_audio_delay`

size_t get_audio_delay() const;

Returns the audio delay in samples at the initialized host rate. Query after successful initialization and again after changing audio configuration. This is not elapsed CPU time. The wrapper asserts C success and has a zero fallback if assertions are disabled.

`aic::ProcessorContext::update_bearer_token`

ErrorCode update_bearer_token(const std::string& token) const;

Replaces local credentials using token.c_str(). Both the original and replacement credentials must use supported JWT form. Returns Success, LicenseFormatInvalid, other license errors or TokenUpdateUnsupported (and NullPointer for an invalid handle). Success does not prove backend acceptance. Run on a control thread. See authentication.

`aic::ProcessorParameter`

Use only these enum class members, whose underlying type is int.

Member	Value	Range, units and default
`ProcessorParameter::Bypass`	0	0 means off; greater than 0 through 1 means on. Default off; getter returns 0 or 1. Preserves delay alignment.
`ProcessorParameter::EnhancementLevel`	1	0–1 inclusive. Model-specific default, falling back to 1. Model metadata can scale the effective strength.

C++ API index · Streams and state · Audio format

Example: check each processing call

Use a successfully initialized processor and keep its buffer alive for the call. This helper propagates the SDK status to the application.

#include "aic.hpp"

aic::ErrorCode enhance_block(aic::Processor& processor, float* audio, size_t count) {
    return processor.process(audio, count);
}

SDK

API reference

Upgrades

LiveKit

AI tools

Historical migrations

C++ enhancement and processor control

`aic::Processor`

`aic::Processor::create`

`aic::Processor::initialize`

`aic::Processor::process`

`aic::Processor::terminate_session`

`aic::Processor::create_context`

`aic::ProcessorContext`

`aic::ProcessorContext::reset`

`aic::ProcessorContext::set_parameter`

`aic::ProcessorContext::get_parameter`

`aic::ProcessorContext::get_audio_delay`

`aic::ProcessorContext::update_bearer_token`

`aic::ProcessorParameter`

Example: check each processing call

​aic::Processor

​aic::Processor::create

​aic::Processor::initialize

​aic::Processor::process

​aic::Processor::terminate_session

​aic::Processor::create_context

​aic::ProcessorContext

​aic::ProcessorContext::reset

​aic::ProcessorContext::set_parameter

​aic::ProcessorContext::get_parameter

​aic::ProcessorContext::get_audio_delay

​aic::ProcessorContext::update_bearer_token

​aic::ProcessorParameter

​Related

​Example: check each processing call

`aic::Processor`

`aic::Processor::create`

`aic::Processor::initialize`

`aic::Processor::process`

`aic::Processor::terminate_session`

`aic::Processor::create_context`

`aic::ProcessorContext`

`aic::ProcessorContext::reset`

`aic::ProcessorContext::set_parameter`

`aic::ProcessorContext::get_parameter`

`aic::ProcessorContext::get_audio_delay`

`aic::ProcessorContext::update_bearer_token`

`aic::ProcessorParameter`

Related

Example: check each processing call