Rockchip ISP30 Development: Complete RK3588 RkAiq API and Debugging Guide

This platform reference preserves the complete technical body of the 436-page English V1.2.5 source (PDF pp.16–436), including the RK-RAW formats and the final error-code and abbreviation chapters. No corresponding Chinese PDF was supplied. Chinese and Russian are full translations of this English version; all 42 original technical figures come from the English PDF, including Chinese labels already present there. Ten image-based RAW layout/format tables are additionally transcribed as editable tables. No whole-page images replace the body.

The source specifies RK3588 / Linux 5.10, with BuildRoot and Android marked Y and Debian and Yocto marked N. These are historical source records, not a promise of support in every BSP. For ArmSoM boards, verify the exact SoC, ISP generation, sensor/VCM, kernel, AIQ library, IQ file and SDK/BSP branch first. ArmSoM Sige7 is an RK3588 board, but this article’s APIs and examples have not been validated on its hardware. All measurements and examples belong to the source; no hardware commands or camera/motor operations were executed.

Source issues: repeated API headings, mixed ISP generations and types, conflicting units, defaults, log levels and RAW field descriptions are retained and listed in the editorial notes. Values and identifiers are not silently corrected. Code comments remain in their original language. Commands and APIs can alter camera or motor state; adapt and review before use.

EDITORIAL-NOTES · ArmSoM Sige7 · ArmSoM camera documentation · Rockchip Linux

1. General overview

1.1 Structure diagram

RK3588 VI as a general term for video input modules, contains:

Interface and data acquisition part: C/DPHY, DVP, CSI, VICAP

Image processing part: ISP-0,ISP-1,FEC-0,FEC-1

The RK3588 ISP belongs to the RK ISP v3.0 version, and subsequent documents are identified as ISP30.

1.2 mode of operation

Single ISP Single CIS (CMOS Image Sensor):

RAW pass-through/online mode: The blue arrows in the block diagram indicate the data flow 1.0 path

Raw readback/offline mode: Orange arrows in the block diagram indicate traffic 1.1, 1.2 paths

Dual ISP 2-in-1 mode for single CIS:

The 2-in-1 mode supports ISP-0/ISP-1 to process the left and right parts of a single CIS image separately to support large resolution CIS.

Multi-CIS :

Single ISP adopts Raw readback/offline mode, which can support multi-CIS input in time-division multiplexing.

1.3 Overview of performance and constraints

Supported resolutions and throughput:

Support Raw12 data entry.

ISP30 supports processing Raw12 data. The Raw14 data input discards the low bits for Raw12 processing. Image data input with a bit width of less than 12 bits will supplement the low bit to Raw12 processing.

Support for Bayer color CIS, Mono CIS.

Support 3-in-1 multi-frame HDR. The following types of HDR CIS are supported:

Lowest latency for ISP30 data output to DDR notification stage in Raw pass-through/online mode: approx. image frame transmission time/15.

In ISP time-division multiplexing mode, a single ISP supports up to four data source inputs.

In RAW pass-through/online mode, the minimum image frame is blanked by 136 lines and the minimum image line is blanked by 16 pixels

The CSM module does not support YUV limit range conversion, see the IMGPROC/CSM module API description for details

2. Overview

ISP30 includes a series of image processing algorithm modules, mainly including: dark current correction, dead pixel correction, 3A, HDR, lens shadow correction, lens distortion correction, 3DLUT, denoising (including RAW domain denoising, multi-frame noise reduction, color denoising, etc.), sharpening, etc.

ISP30 includes hardware algorithm implementation and software logic control part, RkAiq is the implementation of software logic control part.

The main functions of the RkAiq software module are: to obtain image statistics from the ISP driver, combine IQ Tuning parameters, use a series of algorithms to calculate new ISP, Sensor and other hardware parameters, and continuously iterate the process to finally achieve the best image effect.

2.1 Feature description

Figure 1-1 ISP21 system block diagram

The overall software and hardware block diagram of ISP30 is shown in Figure 1-1. The sensor outputs a data stream to the ISP HW, WHICH IN TURN OUTPUTS THE IMAGE AFTER A SERIES OF IMAGE PROCESSING ALGORITHMS. RkAiq continuously obtains statistical data from ISP HW, and generates new parameters through algorithms such as 3A to feed back to each hardware module. Tuning tool can debug parameters online in real time, and after debugging, a new IQ parameter file can be saved and generated.

2.2 RkAiq architecture

Figure 1-2 Overall architecture diagram of RkAiq

1. The ISP30 RkAiq software design idea is shown in Figure 1-2. It is mainly divided into the following four parts:

1. RkAiq lib dynamic library. The library contains the main logical part, which is responsible for obtaining statistics from the driver and passing them to the individual algorithm libraries.

2. Integrated algo libs。 The static algorithm library provided by Rk is registered with the RkAiq lib dynamic library by default.

3. customer 3A libs。 Customers can implement their own 3A algorithm library or other algorithm libraries according to the algorithm library interface definition. After you register a custom algorithm library with the RkAiq lib dynamic library, you can choose whether to run the custom library or the Rk library according to the provided interface.

4. IQ file。 IQ tuning result files store algorithm-related parameters and some system static parameters such as CIS.

2.3 Software architecture

Figure 1-3 Block diagram of software architecture

The ISP30 software block diagram is shown in Figure 1-3. It is mainly divided into the following three layers:

1. kernel layer。 This layer contains all hardware drivers for the camera system, mainly ISP drivers, sensor drivers, VCM drivers, flashlight drivers, IrCutter drivers and so on. The drivers are based on V4L2 and the Media framework.

2. framework layer。 This layer is the integration layer of RkAiq lib, which has two integration methods:

IspServer mode In this way, the Rkaiq lib runs on the IspServer standalone process, with which the client communicates via dbus. In addition, this method can provide images with ISP debugging effect for existing third-party applications such as v4L-CTL without modifying the source code.

Direct integration RkAiq lib can be integrated directly into applications.

3. user layer. User application layer.

2.4 Software processes

Figure 1-4 Flow chart

The RkAiq interface call process is shown in Figure 1-4. The dotted box part in the figure is optional, and the blue font part is the configuration that the application needs to use with the RkAiq process.

configure media pipeline。 Optionally, configure the ISP30 pipeline, such as sensor output resolution, etc., the driver has a default configuration. rk_aiq_uapi2_sysctl_init。 Initialize RkAiq, including IQ tuning parameters and initialization of various algorithm libraries. other Aiq or algo params uapis。 Optionally, you can configure the required parameters through the API interface provided by each algorithm, and register third-party algorithm libraries. rk_aiq_uapi2_sysctl_prepare。 Prepare the initialization parameters of each algorithm library and each hardware module, and set them to the driver.

video capture start。 This process is enabled for the application ISP traffic, and the process needs to be called after rk_aiq_uapi2_sysctl_prepare.

rk_aiq_uapi2_sysctl_start。 Start the RkAiq internal flow, after the interface call is successful, the sensor starts to output data, the ISP starts processing data, and outputs the processed image.

Rkaiq running。 RkAiq continuously obtains statistics from the ISP driver, calls algorithms such as 3A to calculate new parameters, and applies new parameters to the driver. PC Online Tuning Tool。 The PC can adjust the parameters online via the Tuning Tool. video capture stop。 Before stopping the RkAiq process, you need to stop the data flow section. rk_aiq_uapi2_sysctl_stop。 Stop the RkAiq running process. You can adjust the parameters and start it again or start it directly.

rk_aiq_uapi2_sysctl_deinit。 Deinitialize RkAiq.

2.5 API description

The APIs provided by RKAiq are divided into two levels: functional-level APIs and module-level APIs.

Functional level API: Based on module-level API packaging, mainly for product applications based on some simple functional design of the module.

Module-level API: Detailed parameter settings and queries for this module, without API differentiation of functions.

The module-level APIs provided by RKAiq support synchronous and asynchronous modes, and functional- level APIs are encapsulated by default in the synchronous mode of module-level APIs.

Sync mode: This mode is a blocking API, AIQ basically updates parameters with video frames as granularity, and in synchronous mode, the time that the thread calling the API may be blocked <= video frame cycle time.

Asynchronous Mode (ASync): This mode is a non-blocking API, the AIQ framework will store API setting parameters in the internal parameter buffer, and set the latest ISP parameter setting to the hardware at the time.

Instructions for using the synchronous asynchronous mode of module-level APIs

The second parameter structure of the module-level API is generally a collection of setting parameters, called a property structure. The internal rk_aiq_uapi_sync_t members of the structure can configure the call mode of the current API, referring to the following data types for details:

2.5.1 rk_aiq_uapi_sync_t

【Description】 Module sync mode

【Definition】

 typedef struct rk_aiq_uapi_sync_s {
     rk_aiq_uapi_mode_sync_e     sync_mode;
     bool                        done;
 } rk_aiq_uapi_sync_t;

【Member】

The AIQ API reference code is divided into modules, and API examples are provided separately, which is recommended for customers to refer to directly

rkisp_demo/demo/sample

3. System control

3.1 Feature overview

The system control section contains AIQ public attribute configuration, initializing AIQ, running AIQ, exiting AIQ, setting AIQ modules and other functions.

3.2 API Reference

3.2.1 rk_aiq_uapi2_sysctl_preInit

【Description】 Before initializing AIQ, preset some parameters, such as the IQ file used.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_preInit (const char* sns_ent_name,
                          rk_aiq_working_mode_t mode,
                          const char* force_iq_file);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should precede rk_aiq_uapi2_sysctl_init call

The parameter mode is only used to select IQ files, and does not configure the ISP operating mode, which needs to be configured in rk_aiq_uapi2_sysctl_prepare. If the parameter force_iq_file is not empty, the mode parameter is invalid

Parameter force_iq_file is the full path

This function is not required and is only used to change some default settings before rk_aiq_uapi2_sysctl_init

3.2.2 rk_aiq_uapi2_sysctl_preInit_scene

【Description】 Before initializing AIQ, select IQ Scenario Parameters.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_preInit_scene (const char* sns_ent_name,
                          const char *main_scene,
                         const char *sub_scene);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should precede rk_aiq_uapi2_sysctl_init call

main_scene needs to be selected according to the main scene array in the IQ file, the default is generally “normal”

sub_scene needs to be selected according to the sub-scene array in the main scene in the IQ file, the default is generally “day”

Since the default selected scene is normal-day, if you want to run hdr-day, or other custom modes, You need to call this function to specify, otherwise the IQ parameter may be incorrect

3.2.3 rk_aiq_uapi2_sysctl_switch_scene

【Description】 After initializing AIQ, switch the IQ scenario parameters.

【Grammar】

 int
 rk_aiq_uapi2_sysctl_switch_scene (const rk_aiq_sys_ctx_t* sys_ctx,
                          const char *main_scene,
                         const char *sub_scene);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Called after rk_aiq_uapi2_sysctl_init

main_scene needs to be selected based on the array of main scenes in the IQ file

sub_scene needs to be selected based on the array of subscenes in the main scene in the IQ file

This interface involves IQ dynamic switching, which is currently inadequately tested and may cause unexpected results, so use with caution

3.2.4 rk_aiq_uapi2_sysctl_init

【Description】 Initialize the AIQ context.

【Grammar】

 rk_aiq_sys_ctx_t*
 rk_aiq_uapi2_sysctl_init (const char* sns_ent_name,
                          const char* iq_file_dir,
                          rk_aiq_error_cb err_cb,
                          rk_aiq_metas_cb metas_cb);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should precede other function calls.

3.2.5 rk_aiq_uapi2_sysctl_deinit

【Description】 Deinitialize the AIQ context.

【Grammar】

 void
 rk_aiq_uapi2_sysctl_deinit( rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should not be called when AIQ is in the start state.

3.2.6 rk_aiq_uapi2_sysctl_prepare

【Description】 Prepare the AIQ operating environment.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_prepare(const rk_aiq_sys_ctx_t* ctx,
                            uint32_t  width,
                            uint32_t  height,
                            rk_aiq_working_mode_t mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should be called before rk_aiq_uapi2_sysctl_start function.

If you need to call this function after the rk_aiq_uapi2_sysctl_start, call the rk_aiq_uapi2_sysctl_stop function first, and then call rk_aiq_uapi2_sysctl_prepare to reprepare the running environment.

3.2.7 rk_aiq_uapi2_sysctl_start

【Description】 Start the AIQ control system. After AIQ is started, it will continuously obtain 3A statistics from the ISP driver, run the 3A algorithm, and apply the calculated new parameters.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_start(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

Should be called after the rk_aiq_uapi2_sysctl_prepare function.

3.2.8 rk_aiq_uapi2_sysctl_stop

【Description】 Stop the AIQ control system.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_stop(const rk_aiq_sys_ctx_t* ctx, bool keep_ext_hw_st);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.9 rk_aiq_uapi2_sysctl_getStaticMetas

【Description】 Query sensor corresponds to static information such as resolution, data format, etc.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_getStaticMetas(const char* sns_ent_name,
 rk_aiq_static_info_t* static_info);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.10 rk_aiq_uapi2_sysctl_enumStaticMetas

【Description】 Enumerates the static information obtained by AIQ.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_enumStaticMetas(int index, rk_aiq_static_info_t*
 static_info);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.11 rk_aiq_uapi2_sysctl_enableAxlib

【Description】 Set the custom algorithm library running status.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_enableAxlib(const rk_aiq_sys_ctx_t* ctx,
                                const int algo_type,
                                const int lib_id,
                                bool enable);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

If the lib_id is equivalent to the currently running algorithm library, this function can be called in any state except uninitialized.

In other cases, it is only called in the prepared state, and the algorithm library identified by the algo_type will be replaced by the new algorithm library identified by lib_id.

3.2.12 rk_aiq_uapi2_sysctl_getAxlibStatus

【Description】 Gets the algorithm library status.

【Grammar】

 bool
 rk_aiq_uapi2_sysctl_getAxlibStatus(const rk_aiq_sys_ctx_t* ctx,
                                   const int algo_type,
                                   const int lib_id);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.13 rk_aiq_uapi2_sysctl_getEnabledAxlibCtx

【Description】 Gets the context structure of the enable algorithm library.

【Grammar】

 const RkAiqAlgoContext*
 rk_aiq_uapi2_sysctl_getEnabledAxlibCtx(const rk_aiq_sys_ctx_t* ctx, const int
 algo_type);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

【Note】

The returned algorithm context struct will be used by the internal private function. For user-defined algorithm libraries, the function should be called after the rk_aiq_uapi2_sysctl_enableAxlib, otherwise NULL will be returned.

3.2.14 rk_aiq_uapi2_sysctl_setCpsLtCfg

【Description】 Set fill light control information.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_setCpsLtCfg(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_cfg_t* cfg);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.15 rk_aiq_uapi2_sysctl_getCpsLtInfo

【Description】 Get fill light control information.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_getCpsLtInfo(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_info_t* info);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.16 rk_aiq_uapi2_sysctl_queryCpsLtCap

【Description】 Check the support capabilities of fill lights.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_queryCpsLtCap(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_cap_t* cap);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.17 rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd

【Description】 Query the sensor entity name corresponding to the video node.

【Grammar】

 const char* rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd(const char* vd);

【Parameters】

【Return Value】

【Note】

The parameter must be the ISPP scale node path.

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.18 rk_aiq_uapi2_sysctl_updateIq

【Description】 Dynamically update the currently used IQ parameter file without stopping the data flow.

【Grammar】

 XCamReturn rk_aiq_uapi2_sysctl_updateIq(const rk_aiq_sys_ctx_t* sys_ctx, char*
 iqfile);

【Parameters】

【Return Value】

【Note】

iqfile needs to be a full path.

Updating IQ parameters does not mean that the operating mode can be switched, such as switching HDR and normal, can not be updated IQ file implementation; However, the switching of some functions can be achieved through different configurations of IQ parameters, such as day and night switching Switching is achieved entirely through IQ configuration.

When switching IQ, the configuration parameters in IQ will override the settings of the user API. For example, AWB module can be configured manually and automatically in IQ mode, then after executing this function, no matter what mode the current AWB is in, it will eventually be overwritten by the default configuration in the new IQ.

【Requirements】

Header file: rk_aiq_user_api2_sysctl.h

Library file: librkaiq.so

3.2.19 rk_aiq_uapi2_sysctl_getCrop

【Description】 Get the crop parameter.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_sysctl_getCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t
 *rect);

【Parameters】

【Return Value】

3.3 Data type

3.3.1 rk_aiq_working_mode_t

【Description】 AIQ pipeline working mode

【Definition】

 typedef enum {
     RK_AIQ_WORKING_MODE_NORMAL,
     RK_AIQ_WORKING_MODE_ISP_HDR2    = 0x10,
     RK_AIQ_WORKING_MODE_ISP_HDR3    = 0x20,
 } rk_aiq_working_mode_t;

【Member】

【Precautions】

You need to query the mode supported by sensor and AIQ first, if the set mode is not supported, the setting is invalid.

3.3.2 rk_aiq_static_info_t

【Description】 AIQ static information

【Definition】

 typedef struct {
     rk_aiq_sensor_info_t    sensor_info;
     rk_aiq_lens_info_t      lens_info;
     bool has_lens_vcm;
     bool has_fl;
     bool fl_strth_adj_sup;
     bool has_irc;
     bool fl_ir_strth_adj_sup;
 } rk_aiq_static_info_t;

【Member】

3.3.3 rk_aiq_sensor_info_t

【Description】 Sensor information

【Definition】

 typedef struct {
     char sensor_name[32];
     rk_frame_fmt_t  support_fmt[SUPPORT_FMT_MAX];
     int32_t num;
     /* binded pp stream media index */
     int8_t binded_strm_media_idx;
 } rk_aiq_sensor_info_t;

【Member】

3.3.4 rk_aiq_module_id_t

【Description】 AIQ module ID

【Definition】

 typedef enum {
     RK_MODULE_INVAL = 0,
     RK_MODULE_DPCC,
     RK_MODULE_BLS,
     RK_MODULE_LSC,
     RK_MODULE_AWB_GAIN,
     RK_MODULE_CTK,
     RK_MODULE_GOC,
     RK_MODULE_SHARP,
     RK_MODULE_AE,
     RK_MODULE_AWB,
     RK_MODULE_NR,
     RK_MODULE_GIC,
     RK_MODULE_3DLUT,
     RK_MODULE_LDCH,
     RK_MODULE_TNR,
     RK_MODULE_FEC,
     RK_MODULE_MAX
 }rk_aiq_module_id_t;

【Member】

3.3.5 rk_aiq_cpsl_cfg_t

【Description】 The fill light sets the information structure

【Definition】

 typedef struct rk_aiq_cpsl_cfg_s {
     RKAiqOPMode_t mode;
     rk_aiq_cpsls_t lght_src;
     bool gray_on; /*!< force to gray if light on */
     union {
         struct {
             float sensitivity; /*!< Range [0-100] */
             uint32_t sw_interval; /*!< switch interval time, unit  seconds */
         } a; /*< auto mode */
         struct {
             uint8_t on; /*!< disable 0, enable 1 */
             float strength_led; /*!< Range [0-100] */
             float strength_ir; /*!< Range [0-100] */
         } m; /*!< manual mode */
     } u;
 } rk_aiq_cpsl_cfg_t;

【Member】

3.3.6 rk_aiq_cpsl_info_t

【Description】 The fill light queries the information structure

【Definition】

 typedef struct rk_aiq_cpsl_info_s {
     int32_t mode;
     uint8_t on;
     bool gray;
     float strength_led;
     float strength_ir;
     float sensitivity;
     uint32_t sw_interval;
     int32_t lght_src;
 } rk_aiq_cpsl_info_t;

【Member】

3.3.7 rk_aiq_cpsl_cap_t

【Description】 The fill light supports the capability structure

【Definition】

 typedef struct rk_aiq_cpsl_cap_s {
     int32_t supported_modes[RK_AIQ_OP_MODE_MAX];
     uint8_t modes_num;
     int32_t supported_lght_src[RK_AIQ_CPSLS_MAX];
     uint8_t lght_src_num;
     rk_aiq_range_t strength_led;
     rk_aiq_range_t sensitivity;
     rk_aiq_range_t strength_ir;
 } rk_aiq_cpsl_cap_t;

【Member】

3.3.8 rk_aiq_rect_t

【Description】 Define the crop parameter structure

【Definition】

 typedef struct rk_aiq_rect_s {
     int left;
     int top;
     int width;
     int height;
 } rk_aiq_rect_t;

【Member】

4. Offline frame processing

4.1 Overview

RKAIQ provides offline RAW frame processing function, that is, RK custom RAW format files are parsed by RKAIQ and sent to ISP for processing, and output as images that can display normal effects.

Note: The offline frame processing feature has not been tested.

4.2 Functional block diagram

Block diagram of offline frame processing

4.3 Description of the feature

Support RK-RAW file input. With the file input interface, the calling process is blocked until the file processing is complete and the output is successful.

Support RK-RAW buffer input, asynchronous processing mode. Using the buffer input interface, the calling process will not block, and the callback function (if there is a registered callback function) will be called after the buffer processing is completed.

Support RK-RAW buffer input, synchronous processing mode. With the buffer input interface, the calling process will be blocked until the buffer processing is complete and the output is successful.

4.4 RK-RAW format description

See the RK RAW File Format documentation

4.5 Supported RAW formats

Support raw8/raw10/raw12, support BGGR/GBRG/GRBG/RGGB four bayer formats.

4.6 API reference

4.7 Data structures

4.8 Considerations

Using the RK Raw data processing function, when creating an AIQ Context, the parameter sns_ent_name of the rk_aiq_uapi2_sysctl_init interface must be “FakeCamera”.

The processing of raw data relies on IQ XML effect files, and the resolution of the XML file should be generated at the same resolution as the incoming RK Raw frame data. The effect file must be named FakeCamera.xml and placed in the loading path of the XML file.

4.9 Reference example

For more information about how to use the offline frame processing API, see rkisp_demo, and the path is YOUR_SDK_DIR/external/camera_engine_rkaiq/rkisp_demo.

5. Camera group

5.1 Overview

For example, in application scenarios such as surround view, multiple cameras need to be grouped together for unified management, and parameters such as exposure need to be set in a unified manner. You can create a group to classify multiple cameras into the same group. The Camera Group API is implemented based on the AIQ API of a single camera, unless otherwise specified, the API that applies to a single AIQ also applies to a Camera group, and the internal implementation of AIQ will distribute requests to a Camera group or a single Camera according to the type of Context passed.

5.1.1 rk_aiq_uapi2_camgroup_create

【Description】 When you create a Camera group, you will create a separate AIQ ctx for each Camera, and then hand it over to the Group Ctx to manage

【Grammar】

 rk_aiq_camgroup_ctx_t*
 rk_aiq_uapi2_camgroup_create (rk_aiq_camgroup_instance_cfg_t* cfg);

【Parameter】

【Return value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h

Library files：librkaiq.so

【Note】

Different from rk_aiq_uapi2_sysctl_init, rk_aiq_uapi2_sysctl_init create an AIQ runtime environment with a single camera. Use rk_aiq_uapi2_sysctl_init to create a sensor entity that runs and no longer use rk_aiq_uapi2_camgroup_create to create a group runtime and vice versa.

Since the default IQ scene is normal-day, if you need to use HDR or other modes, you need to use rk_aiq_uapi2_sysctl_preInit_scene to set it in advance.

5.1.2 rk_aiq_uapi2_camgroup_prepare

【Description】 According to the selected pipeline mode, initialization parameters are generated and pipelines are created. The rk_aiq_uapi2_sysctl_prepare corresponding to the AIQ ctx of each Camera will be called.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_prepare (rk_aiq_camgroup_ctx_t* camgroup_ctx,
 rk_aiq_working_mode_t mode);

【Parameter】

【Return value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.3 rk_aiq_uapi2_camgroup_start

【Description】 Run the Camera group. The rk_aiq_uapi2_sysctl_start corresponding to the AIQ ctx of each Camera will be called.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_start (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.4 rk_aiq_uapi2_camgroup_stop

【Description】 Stop the Camera group. The rk_aiq_uapi2_sysctl_stop corresponding to the AIQ ctx of each Camera will be called.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_stop (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.5 rk_aiq_uapi2_camgroup_destroy

【Description】 Destroy the Camera group. The rk_aiq_uapi2_sysctl_deinit corresponding to the AIQ ctx of each Camera will be called.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_destroy (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.6 rk_aiq_uapi2_camgroup_getOverlapMap

【Description】 In the surround view scenario, obtain the overlapping area information of each camera from the CameraGroup context.

【Grammar】

 struct RK_PS_SrcOverlapMap*
 rk_aiq_uapi2_camgroup_getOverlapMap (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.7 rk_aiq_uapi2_camgroup_getOverlapMap

【Description】 In the surround view scenario, you can obtain the overlapping area information of each camera from the file.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_getOverlapMap_from_file (const char* map_file,
                                                             struct
 RK_PS_SrcOverlapMap** overlapMap);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.8 rk_aiq_uapi2_camgroup_getAiqCtxBySnsNm

【Description】 Obtain the AIQ context of a single Camera by using the Sensor entity name in the group.

【Grammar】

 rk_aiq_sys_ctx_t*
 rk_aiq_uapi2_camgroup_getAiqCtxBySnsNm (rk_aiq_camgroup_ctx_t* camgroup_ctx,
 const char* sns_entity_name);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.9 rk_aiq_uapi2_camgroup_getCamInfos

【Description】 Obtain information about cameras in the group, such as the name of the sensor entity.

【Grammar】

 XCamReturn
 rk_aiq_uapi2_camgroup_getCamInfos (rk_aiq_camgroup_ctx_t* camgroup_ctx,
                    rk_aiq_camgroup_camInfos_t* camInfos);

【Parameter】

【Return Value】

【Demand】

Header files：rk_aiq_user_api2_camgroup.h Library files：librkaiq.so

5.1.10 rk_aiq_uapi2_camgroup_bind

【Description】 Reserved interface, not implemented.

5.1.11 rk_aiq_uapi2_camgroup_unbind

【Description】 Reserved interface, not implemented.

5.2 Data Structure

5.2.1 rk_aiq_camgroup_instance_cfg_t

【Illustrate】 Carmelaghrup configuration parameters

【Definition】

   typedef struct rk_aiq_camgroup_instance_cfg_s {
       const char* sns_ent_nm_array[RK_AIQ_CAM_GROUP_MAX_CAMS];
       int sns_num;
       const char* config_file_dir;
        /* followings are relative path to config_file_dir */
        const char* single_iq_file;
        const char* group_iq_file;
        const char* overlap_map_file;
    } rk_aiq_camgroup_instance_cfg_t;

【Member】

5.2.2 rk_aiq_camgroup_camInfos_t

【Illustrate】 Information about each camera in the Camera group

【Definition】

    typedef struct rk_aiq_camgroup_camInfos_s {
        int valid_sns_num;
        const char* sns_ent_nm[RK_AIQ_CAM_GROUP_MAX_CAMS];
        int sns_camPhyId[RK_AIQ_CAM_GROUP_MAX_CAMS];
   } rk_aiq_camgroup_camInfos_t;

【Member】

5.2.3 struct RK_PS_SrcOverlapMap

【Illustrate】 Define the overlapping area of the camera

【Definition】

        struct RK_PS_SrcOverlapMap
      {
            char versionInfo[64];
            RK_PS_SrcOverlapPosition srcOverlapPositon[8];
            unsigned char overlapMap[15 * 15 * 8];
        };

【Member】

6. AE

6.1 Overview

The AE module achieves the function of obtaining the exposure of the current image according to the automatic metering system, and then automatically configuring the lens aperture, sensor shutter and gain to obtain the best image quality.

6.2 Important concepts

Exposure time: The time when the sensor accumulates charge is the time between the sensor pixel being exposed and the charge is read.

Exposure gain: The total amplification factor of the output charge of the sensor, generally digital gain and analog gain, analog gain will introduce slightly less noise, so analog gain is generally preferred.

Aperture: Aperture is a mechanism in the lens that can change the size of the clear aperture.

Anti-flicker: The picture flicker caused by the mismatch between the power frequency of the lamp and the frame rate of the sensor is generally achieved by limiting the exposure time and modifying the frame rate of the sensor.

6.3 Description of the feature

The AE module consists of AE statistics and the algorithm of AE control strategy.

6.4 Feature-level API reference

6.4.1 rk_aiq_uapi2_setAeLock

【Description】

Set AE exposure lock function.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAeLock（const rk_aiq_sys_ctx_t* ctx, bool on);

【Parameters】

【Return Value】

6.4.2 rk_aiq_uapi2_setExpMode

【Description】 Set exposure mode, support setting auto exposure and manual exposure.

【Grammar】

 XCamReturn rk_aiq_uapi2_setExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameters】

【Return Value】

【Note】

The gain and exposure time when the exposure mode is cut to manual mode use the initial values defined in the image effect file. If you need to set the exposure value while switching the manual mode, you can use the rk_aiq_uapi2_setManualExp interface.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.3 rk_aiq_uapi2_getExpMode

【Description】 Gets the exposure mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_getExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.4 rk_aiq_uapi2_setManualExp

【Description】 Use the manual exposure mode and set the gain and exposure time.

【Grammar】

 XCamReturn rk_aiq_uapi2_setManualExp(const rk_aiq_sys_ctx_t* ctx, float gain,
 float time);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.5 rk_aiq_uapi2_setExpGainRange

【Description】** Set the gain range.

【Grammar】

 XCamReturn rk_aiq_uapi2_setExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *gain);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.6 rk_aiq_uapi2_getExpGainRange

【Description】 Get the gain range.

【Grammar】

 XCamReturn rk_aiq_uapi2_getExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *gain);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.7 rk_aiq_uapi2_setExpTimeRange

【Description】 Set the exposure time range.

【Grammar】

 XCamReturn rk_aiq_uapi2_setExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *time);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.8 rk_aiq_uapi2_getExpTimeRange

【Description】 Gets the exposure time range.

【Grammar】

 XCamReturn rk_aiq_uapi2_getExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *time);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.9 rk_aiq_uapi2_setBLCMode

【Description】 Backlight compensation switch, locale.

【Grammar】

 XCamReturn rk_aiq_uapi2_setBLCMode(const rk_aiq_sys_ctx_t* ctx, bool on,
 aeMeasAreaType_t areaType);

【Parameters】

【Return Value】

【Note】

The interface is only available in linear mode.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.10 rk_aiq_uapi2_setBLCStrength

【Description】 Set dark areas to boost intensity.

【Grammar】

 XCamReturn rk_aiq_uapi2_setBLCStrength(const rk_aiq_sys_ctx_t* ctx, int
 strength);

【Parameters】

【Return Value】

【Note】

The interface is only available in linear mode.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.11 rk_aiq_uapi2_setHLCMode

【Description】 Bright light suppression switch.

【Grammar】

 XCamReturn rk_aiq_uapi2_setHLCMode(const rk_aiq_sys_ctx_t* ctx, bool on);

【Parameters】

【Return Value】

【Note】

The interface is only available in linear mode.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.12 rk_aiq_uapi2_setHLCStrength

【Description】 Set the intensity of intense light suppression.

【Grammar】

 XCamReturn rk_aiq_uapi2_setHLCStrength(const rk_aiq_sys_ctx_t* ctx, int
 strength);

【Parameters】

【Return Value】

【Note】

The interface is only available in linear mode.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.sov

6.4.13 rk_aiq_uapi2_setAntiFlickerEn

【Description】 Set the anti-power frequency flicker switch.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool on)；

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.14 rk_aiq_uapi2_getAntiFlickerEn

【Description】 Set the anti-power frequency flicker switch.

【Grammar】

 XCamReturn rk_aiq_uapi2_getAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool* on)；

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.15 rk_aiq_uapi2_setAntiFlickerMode

【Description】 Set the anti-flash mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx,
 antiFlickerMode_t mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.16 rk_aiq_uapi2_getAntiFlickerMode

【Description】 Get the anti-flash mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_getAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx,
 antiFlickerMode_t *mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.17 rk_aiq_uapi2_setExpPwrLineFreqMode

【Description】 Set the anti-flash frequency.

【Grammar】

 XCamReturn rk_aiq_uapi2_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx,
 expPwrLineFreq_t freq);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.4.18 rk_aiq_uapi2_getExpPwrLineFreqMode

【Description】** Get the anti-flash frequency.

【Grammar】

 XCamReturn rk_aiq_uapi2_getExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx,
 expPwrLineFreq_t *freq);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

6.5 Functional-level API data types

6.5.1 opMode_t

【Description】 Define automatic manual mode.

【Definition】

 typedef enum opMode_e {
     OP_AUTO = 0,
     OP_MANUALl = 1,
     OP_INVAL
 } opMode_t;

【Member】

6.5.2 paRange_t

【Description】 Define parameter ranges.

【Definition】

 typedef struct paRange_s {
     float max;
     float min;
 } paRange_t;

【Member】

6.5.3 aeMeasAreaType_t

【Description】 Define the AE measurement area type.

【Definition】

 typedef enum aeMeasAreaType_e {
     AE_MEAS_AREA_AUTO = 0,
     AE_MEAS_AREA_UP,
     AE_MEAS_AREA_BOTTOM,
     AE_MEAS_AREA_LEFT,
     AE_MEAS_AREA_RIGHT,
     AE_MEAS_AREA_CENTER,
 } aeMeasAreaType_t;

【Member】

6.5.4 expPwrLineFreq_t

【Description】 Define the anti-flash frequency.

【Definition】

 typedef enum expPwrLineFreq_e {
        EXP_PWR_LINE_FREQ_DIS   = 0,
        EXP_PWR_LINE_FREQ_50HZ  = 1,
        EXP_PWR_LINE_FREQ_60HZ  = 2,
 } expPwrLineFreq_t;

【Member】

6.5.5 antiFlickerMode_t

【Description】 Define the anti-flash mode.

【Definition】

 typedef enum antiFlickerMode_e {
     ANTIFLICKER_NORMAL_MODE = 0,
     ANTIFLICKER_AUTO_MODE = 1,
 } antiFlickerMode_t;

【Member】

6.6 Module-level API reference

6.6.1 rk_aiq_user_api2_ae_setExpSwAttr

【Description】 Set AE exposure software properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setExpSwAttr(const rk_aiq_sys_ctx_t* ctx,
                                 const Uapi_ExpSwAttrV2_t expSwAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

Set manual exposure properties

The exposure components include sensor exposure time, sensor exposure gain, and ISP digital gain. After setting the manual exposure mode, you also need to set the manual state (ManualGainEn, ManualTimeEn, ManualIspDgainEn) and its corresponding manual values for each exposure component. In manual exposure mode, all exposure components are required to be manual, and the value of each exposure component set is limited by the sensor and lens. If the set exposure component value exceeds the sensor’s limit, the algorithm will automatically correct it.

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
 //LinearAE
 expSwAttr.stManual.LinearAE.ManualGainEn = true;
 expSwAttr.stManual.LinearAE.ManualTimeEn = true;
 expSwAttr.stManual.LinearAE.GainValue = 1.0f; /*gain = 1x*/
 expSwAttr.stManual.LinearAE.TimeValue = 0.02f; /*time = 1/50s*/
 //HdrAE (should set all frames)
 expSwAttr.stManual.HdrAE.ManualGainEn = true;
 expSwAttr.stManual.HdrAE.ManualTimeEn = true;
 expSwAttr.stManual.HdrAE.GainValue[0] = 1.0f; /*sframe gain = 1x*/
 expSwAttr.stManual.HdrAE.TimeValue[0] = 0.002f; /*sframe time = 1/500s*/
 expSwAttr.stManual.HdrAE.GainValue[1] = 2.0f; /*mframe gain = 2x*/
 expSwAttr.stManual.HdrAE.TimeValue[1] = 0.01f; /*mframe time = 1/100s*/
 expSwAttr.stManual.HdrAE.GainValue[2] = 4.0f; /*lframe gain = 4x*/
 expSwAttr.stManual.HdrAE.TimeValue[2] = 0.02f; /*lframe time = 1/50s*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set auto exposure properties

Auto exposure can set the range of the exposure component, and if the set exposure component range exceeds the limit of the sensor, the algorithm will automatically correct it.

【Note】: Setting the parameters of the exposure component range is different from the parameter of obtaining the exposure component range.

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
 //set time range in struct "stAdvanced"
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*must enable*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Max = 0.04f; /*time_max =
 0.04*/
 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Min = 0.001f; /*time_min =
 0.001*/
 //HdrAE
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Max = 0.002f; /*sframe
 time_max = 0.02*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Min = 0.001f; /*sframe
 time_min = 0.01*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Max = 0.003f; /*mframe
 time_max = 0.03*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Min = 0.002f; /*mframe
 time_min = 0.02*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Max = 0.04f; /*lframe
 time_max = 0.03*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Min = 0.03f; /*lframe
 time_min = 0.02*/
 //get time range in struct "stAuto"
 printf("linear time range=[%f,%f]\n",
     expSwAttr.stAuto.LinAeRange.stExpTimeRange.Min,
 expSwAttr.stAuto.LinAeRange.stExpTimeRange.Max);
 printf("hdr stime range=[%f,%f], mtime range=[%f,%f], ltime range=[%f,%f]\n",
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[0].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[0].Max,
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[1].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[1].Max,
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[2].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[2].Max);
 //set gain range in struct "stAdvanced"
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*must enable*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = 32.0f; /*gain_max = 32x*/
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = 1.0f; /*gain_min = 1x*/
 //HdrAE
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = 32.0f; /*sframe gain_max
 = 2x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = 1.0f; /*sframe gain_min =
 1x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Max = 64.0f; /*mframe gain_max
 = 64x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Min = 1.0f; /*mframe gian_min =
 1x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Max = 64.0f; /*lframe gain_max
 = 64x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Min = 1.0f; /*lframe gain_min =
 1x*/
 //get gain range in struct "stAuto"
 printf("linear gain range=[%f,%f]\n",
     expSwAttr.stAuto.LinAeRange.stGainRange.Min,
 expSwAttr.stAuto.LinAeRange.stGainRange.Max);
 printf("hdr sgain range=[%f,%f], mgain range=[%f,%f], lgain range=[%f,%f]\n",
     expSwAttr.stAuto.HdrAeRange.stGainRange[0].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[0].Max,
     expSwAttr.stAuto.HdrAeRange.stGainRange[1].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[1].Max,
     expSwAttr.stAuto.HdrAeRange.stGainRange[2].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[2].Max);
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set semi-manual exposure properties

Semi-manual exposure is that at least one of the exposure components (sensor exposure time, sensor exposure gain, ISP digital gain) is manual, and the other exposure components are automatic, otherwise it will exit with an error. For example, in order to realize the semi-automatic exposure function of exposure gain manual, exposure time and ISP digital gain automatic, there are the following two ways to implement it: in the manual exposure mode, set the manual enable of exposure time and ISP digital gain to false, set the manual enable of exposure gain to true, and set the corresponding manual value; Method 2: In the auto exposure mode, the maximum and minimum values of the exposure gain are set to the value that needs to be fixed.

【Note】Method 1: In HDR exposure mode, the manual behavior of all frames is synchronous (that is, the corresponding exposure components of each frame are manually consistent), and at the same time, it is necessary to ensure that the maximum exposure of long frames is greater than the maximum exposure of short frames, and the minimum exposure of long frames is greater than the minimum exposure of short frames; Method 2: In HDR exposure mode, the manual behavior of each frame is allowed to be inconsistent (such as short frame gain manual, long frame gain can be automatic), and at the same time, you need to ensure that the maximum exposure of long frames is greater than the maximum exposure of short frames, and the minimum exposure of long frames is greater than the minimum exposure of short frames.

 //Method One
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
 //LinearAE
 expSwAttr.stManual.LinearAE.ManualGainEn = true;
 expSwAttr.stManual.LinearAE.ManualTimeEn = false;
 expSwAttr.stManual.LinearAE.ManualIspDgainEn = false;
 expSwAttr.stManual.LinearAE.GainValue = 2.0f; /*gain = 2x*/
 //HdrAE (need to set all frames)
 expSwAttr.stManual.HdrAE.ManualGainEn = true;
 expSwAttr.stManual.HdrAE.ManualTimeEn = false;
 expSwAttr.stManual.HdrAE.ManualIspDgainEn = false;
 expSwAttr.stManual.HdrAE.GainValue[0] = 1.0f; /*sframe gain = 1x*/
 expSwAttr.stManual.HdrAE.GainValue[1] = 2.0f; /*mframe gain = 2x*/
 expSwAttr.stManual.HdrAE.GainValue[2] = 4.0f; /*lframe gain = 4x*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
 //Method Two
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
 //set gain range
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*Must be enabled*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = 2.0f; /*gain_max = 2x*/
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = 2.0f;  /*gain_min = 2x*/
 //HdrAE (allow to set only one frame)
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = 2.0f; /*sframe gain_max =
 2x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = 2.0f;  /*sframe gain_min
 = 2x*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set a fixed frame rate or automatic frame reduction

In fixed frame rate mode, the allowed frame rate must not exceed the maximum frame rate defined by the driver, if it exceeds it, there will be a log reminder and the frame rate setting will be disabled.

 //set fixed framemode
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.stAuto.stFrmRate.isFpsFix = true;
 expSwAttr.stAuto.stFrmRate.FpsValue = 25; /*fps = 25*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
 //set auto framemode
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.stAuto.stFrmRate.isFpsFix = false;
 /*Generally, the automatic frame reduction mode is configured by tuning personnel
 in advance with the minimum frame rate and the gain value corresponding to the
 switching frame rate*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set the exposure adjustment speed and delay frame rate

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 //set ae speed
 expSwAttr.stAuto.stAeSpeed.DampOver = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampDark2Bright = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampUnder = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampBright2Dark = 0.8f;
 //set ae delay
 expSwAttr.stAuto.BlackDelayFrame = 2;
 expSwAttr.stAuto.WhiteDelayFrame = 4;
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set up anti-flash

 Uapi_ExpSwAttr_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 //set antifilicker mode
 expSwAttr.stAuto.stAntiFlicker.enable = true;
 expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_50HZ;
 expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE;
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Set the AE weight

Set the 15X15 weight, and the algorithm compresses the weight according to the actual block specifications of the hardware. At present, there are two ways to set the weight: way 1: directly modify the weight in JSON; Method 2: Modify the weight by stadvanced, and if you eliminate the enablement, you can restore the weight back to the JSON (this method is recommended).

For face applications, the recommended use of expSwAttr.stAdvanced.enable = true, use the weight in the expSwAttr.stAdvanced structure when the face appears, and expSwAttr.stAdvanced.enable = false when the face disappears, use the original weight.

 Uapi_ExpSwAttr_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 uint8_t GridWeights[225]={
 0,  0, 1,  2,  2,  3,  4,  5,  4, 3,  2,  2,  1,  0,  0,
 0,  1, 2,  3,  3,  4,  5,  6,  5, 4,  3,  3,  2,  1,  0,
 1,  2, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  2,  1,
 2,  3, 5,  7,  7,  8,  9, 10,  9, 8,  7,  7,  5,  3,  2,
 2,  3, 5,  7,  8,  9, 10, 11, 10, 9,  8,  7,  5,  3,  2,
 2,  4, 6,  8,  9, 10, 11, 12, 11,10,  9,  8,  6,  4,  2,
 2,  4, 6,  9, 10, 11, 12, 13, 12,11, 10,  9,  6,  4,  2,
 3,  5 ,7, 10, 11, 12, 13, 14, 13,12, 11, 10,  7,  5,  3,
 2,  4, 6,  9, 10, 11, 12, 13, 12,11, 10,  9,  6,  4,  2,
 2,  4, 6,  8,  9, 10, 11, 12, 11,10,  9,  8,  6,  4,  2,
 2,  3, 5,  7,  8,  9, 10, 11, 10, 9,  8,  7,  5,  3,  2,
 2,  3, 5,  7,  7,  8,  9, 10,  9, 8,  7,  7,  5,  3,  2,
 1,  2, 4,  6,  6,  7,  8,  9,  8, 7,  6,  6,  4,  2,  1,
 0,  1, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  1,  0,
 0,  1, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  1,  0
 };
 //method one：
 memcpy(expSwAttr.GridWeights.uCoeff, GridWeights,
 sizeof(expSwAttr.GridWeights.uCoeff));
 //method two:
 expSwAttr.stAdvanced.enable = true; //important! true means preferring to use these parameters
 memcpy(expSwAttr.stAdvanced.GridWeights, GridWeights,
 sizeof(expSwAttr.stAdvanced.GridWeights));
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

6.6.2 rk_aiq_user_api2_ae_getExpSwAttr

【Description】 Gets the AE exposure software properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getExpSwAttr(const rk_aiq_sys_ctx_t* ctx,
                         Uapi_ExpSwAttrV2_t* pExpSwAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.3 rk_aiq_user_api2_ae_setLinAeRouteAttr

【Description】 Set the scene exposure allocation strategy for AE in linear mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setLinAeRouteAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_LinAeRouteAttr_t linAeRouteAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

 Uapi_LinAeRouteAttr_t LinAeRouteAttr;
 memset(&LinAeRouteAttr,0x00,sizeof(Uapi_LinAeRouteAttr_t));
 rk_aiq_user_api2_ae_getLinAeRouteAttr(sys_ctx,&LinAeRouteAttr);
 int len = 8;
 float TimeDot[8]={0,0.01,0.01,0.02,0.02,0.03,0.03,0.04};
 float GainDot[8]={1,1,4,4,8,8,16,32};
 float IspGainDot[8]={1,1,1,1,1,1,1,1};
 int PirisDot[8]={512,512,512,512,512,512,512,512};
 LinAeRouteAttr.TimeDot_len = len;
 LinAeRouteAttr.GainDot_len = len;
 LinAeRouteAttr.IspDGainDot_len = len;
 LinAeRouteAttr.PIrisDot_len = len;
 LinAeRouteAttr.GainDot = GainDot;
 LinAeRouteAttr.IspDGainDot = IspGainDot;
 LinAeRouteAttr.TimeDot = TimeDot;
 LinAeRouteAttr.PIrisDot = PirisDot;
 rk_aiq_user_api2_ae_setLinAeRouteAttr(sys_ctx,LinAeRouteAttr);

6.6.4 rk_aiq_user_api2_ae_getLinAeRouteAttr

【Description】 Gets the scene exposure allocation strategy for AE in linear mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getLinAeRouteAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_LinAeRouteAttr_t* pLinAeRouteAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.5 rk_aiq_user_api2_ae_setHdrAeRouteAttr

【Description】 Set the scene exposure allocation strategy for AE in HDR mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setHdrAeRouteAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_HdrAeRouteAttr_t hdrAeRouteAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

 Uapi_HdrAeRouteAttr_t stHdrRoute;
 memset(&stHdrRoute,0x00,sizeof(Uapi_HdrAeRouteAttr_t));
 ret = rk_aiq_user_api2_ae_getHdrAeRouteAttr(ctx,&stHdrRoute);
 int len = 6;
 float HdrTimeDot[3][6] = {0.0, 0.01, 0.01, 0.01, 0.01, 0.01,
                           0.0, 0.02, 0.02, 0.02, 0.02, 0.02,
                           0.0, 0.03, 0.03, 0.03, 0.03, 0.03};
 float HdrGainDot[3][6] = {1, 1, 4, 6, 8, 12,
                           1, 1, 4, 6, 8, 12,
                           1, 1, 4, 6, 8, 12};
 float HdrIspDGainDot[3][6] = {1, 1, 1, 1, 1, 1,
                               1, 1, 1, 1, 1, 1,
                               1, 1, 1, 1, 1, 1};
 int   HdrPIrisGainDot[6] = {1, 1, 1, 1, 1, 1};
 stHdrRoute.Frm0TimeDot_len = len;
 stHdrRoute.Frm0GainDot_len = len;
 stHdrRoute.Frm0IspDGainDot_len = len;
 stHdrRoute.Frm1TimeDot_len = len;
 stHdrRoute.Frm1GainDot_len = len;
 stHdrRoute.Frm1IspDGainDot_len = len;
 stHdrRoute.Frm2TimeDot_len = len;
 stHdrRoute.Frm2GainDot_len = len;
 stHdrRoute.Frm2IspDGainDot_len = len;
 stHdrRoute.PIrisDot_len = len;
 stHdrRoute.Frm0TimeDot = HdrTimeDot[0];
 stHdrRoute.Frm0GainDot = HdrGainDot[0];
 stHdrRoute.Frm0IspDGainDot = HdrIspDGainDot[0];
 stHdrRoute.Frm1TimeDot = HdrTimeDot[1];
 stHdrRoute.Frm1GainDot = HdrGainDot[1];
 stHdrRoute.Frm1IspDGainDot = HdrIspDGainDot[1];
 stHdrRoute.Frm2TimeDot = HdrTimeDot[2];
 stHdrRoute.Frm2GainDot = HdrGainDot[2];
 stHdrRoute.Frm2IspDGainDot = HdrIspDGainDot[2];
 stHdrRoute.PIrisDot = HdrPIrisGainDot;
 ret = rk_aiq_user_api2_ae_setHdrAeRouteAttr(ctx,stHdrRoute);

6.6.6 rk_aiq_user_api2_ae_getHdrAeRouteAttr

【Description】 Gets the scene exposure distribution strategy for AE in HDR mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getHdrAeRouteAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.7 rk_aiq_user_api2_ae_setLinExpAttr

【Description】 Set the AE linear mode exposure parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setLinExpAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_LinExpAttrV2_t linExpAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

Set AE linear mode exposure parameters, including but not limited to: setting to adjust brightness intensity Evbias, setting backlight compensation function BackLightCtrl, setting strong light suppression function OverExpCtrl, etc. It is important to note that backlight compensation and strong light suppression cannot be enabled at the same time.

 Uapi_LinExpAttrV2_t linExpAttr;
 memset(&linExpAttr,0,sizeof(Uapi_LinExpAttrV2_t));
 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &linExpAttr);
 //set Evbias
 printf("Evbias=%f\n", linExpAttr.Evbias);
 linExpAttr.Evbias = 100.0f;
 //set BackLightCtrl
 linExpAttr.BackLightCtrl.Enable = true;
 linExpAttr.BackLightCtrl.StrBias = 200.0f;
 //set OverExpCtrl
 linExpAttr.OverExpCtrl.Enable = true;
 linExpAttr.OverExpCtrl.StrBias = 100.0f;
 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, linExpAttr);

6.6.8 rk_aiq_user_api2_ae_getLinExpAttr

【Description】 Get the AE linear mode exposure parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getLinExpAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_LinExpAttrV2_t* pLinExpAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.9 rk_aiq_user_api2_ae_setHdrExpAttr

【Description】 Set AE HDR mode exposure parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setHdrExpAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_HdrExpAttrV2_t hdrExpAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

Set AE HDR mode exposure parameters, including but not limited to: setting the exposure ratio to manual or automatic, adjusting the brightness intensity Evbias.

 Uapi_HdrExpAttrV2_t HdrExpAttr;
 memset(&HdrExpAttr,0,sizeof(Uapi_HdrExpAttrV2_t));
 ret = rk_aiq_user_api2_ae_getHdrExpAttr(ctx, &HdrExpAttr);
 //set hdr mframe params
 int len = 8;
 float explevel[8] = {0, 0.096, 0.192, 0.384, 0.96, 1.344, 1.92, 3};
 float setpoint[8] = {50, 45, 40, 35, 30, 25, 20, 15};
 HdrExpAttr.HdrAEAttr.MframeCtrl.MExpLevel_len = len;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MSetPoint_len = len;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MExpLevel = explevel;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MSetPoint = setpoint;
 //set ExpRatioType (AUTO/FIX)
 HdrExpAttr.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_AUTO;
 //set Evbias
 HdrExpAttr.Evbias = -100.0f;
 ret = rk_aiq_user_api2_ae_setHdrExpAttr(ctx, HdrExpAttr);

6.6.10 rk_aiq_user_api2_ae_getHdrExpAttr

【Description】 Get the AE HDR mode exposure parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getHdrExpAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_HdrExpAttrV2_t* pHdrExpAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.11 rk_aiq_user_api2_ae_setIrisAttr

【Description】 Set AE aperture control parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx, const
 Uapi_IrisAttrV2_t irisAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

 Uapi_IrisAttrV2_t irisAttr;
 ret = rk_aiq_user_api2_ae_getIrisAttr(ctx, &irisAttr);
 irisAttr.enable = true; /*run AIris*/
 //set P-iris attributes
 irisAttr.IrisType = IRIS_P_TYPE;
 irisAttr.PIrisAttr.TotalStep = 81;
 irisAttr.PIrisAttr.EffcStep = 44;
 irisAttr.PIrisAttr.ZeroIsMax = true;
 uint16_t StepTable[1024] = {512, 511, 506, 499, 491, 483, 474, 465, 456,
                             446, 437, 427, 417, 408, 398, 388, 378, 368,
                             359, 349, 339, 329, 319, 309, 300, 290, 280,
                             271, 261, 252, 242, 233, 224, 214, 205, 196,
                             187, 178, 170, 161, 153, 144, 136, 128, 120,
                             112, 105, 98, 90, 83, 77, 70, 64, 58,
                             52, 46, 41, 36, 31, 27, 23, 19, 16,
                             13, 10, 8, 6, 4, 3, 1, 1, 0,
                             0, 0, 0, 0, 0, 0, 0, 0, 0};
 memcpy(irisAttr.PIrisAttr.StepTable,StepTable,sizeof(irisAttr.PIrisAttr.StepTable
 ));
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);
 //set DC-iris attributes
 irisAttr.IrisType = IRIS_DC_TYPE;
 irisAttr.DCIrisAttr.Kp= 0.5f;
 irisAttr.DCIrisAttr.Ki= 0.2f;
 irisAttr.DCIrisAttr.Kd = 0.3f;
 irisAttr.DCIrisAttr.OpenPwmDuty = 40;
 irisAttr.DCIrisAttr.ClosePwmDuty = 22;
 irisAttr.DCIrisAttr.MinPwmDuty = 0;
 irisAttr.DCIrisAttr.MaxPwmDuty = 100;
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);
 //set manual iris with auto ae
 irisAttr.IrisOpType = RK_AIQ_OP_MODE_MANUAL;
 if(irisAttr.IrisType == IRIS_P_TYPE);
     irisAttr.ManualAttr.PIrisGainValue = 512; /*p-iris F#=1.4*/
 if(irisAttr.IrisType == IRIS_DC_TYPE);
     irisAttr.ManualAttr.DCIrisHoldValue = 20; /*dc-iris PwmDuty=20*/
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);

6.6.12 rk_aiq_user_api2_ae_getIrisAttr

【Description】 Gets the AE aperture control parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx, const
 Uapi_IrisAttrV2_t* irisAttr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.13 rk_aiq_user_api2_ae_setExpWinAttr

【Description】 Set the AE Statistics window properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_setExpWinAttr(const rk_aiq_sys_ctx_t* sys_ctx, const
 Uapi_ExpWin_t ExpWin);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

【Example】

Modify the AE statistical coordinates according to the face position to realize brightness statistics for the face area.

Note: When setting statistical coordinates, ensure that ExpWin.h_offs+ExpWin.h_size<=pic_width and ExpWin.v_offs+ExpWin.v_size<=pic_height.

 Uapi_ExpWin_t ExpWin;
 //Suppose the sensor resolution is 2688X1520, the lateral offset of the face from the upper left corner of the screen is 100 pixel, the vertical offset is 100 pixel, and the face size is a square with a side length of 100 pixel
 ExpWin.h_offs=100;
 ExpWin.v_offs=100;
 ExpWin.h_size=100;
 ExpWin.v_size=100;
 rk_aiq_user_api2_ae_setExpWinAttr(ctx, ExpWin);

6.6.14 rk_aiq_user_api2_ae_getExpWinAttr

【Description】 Gets the AE Statistics window properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_getExpWinAttr(const rk_aiq_sys_ctx_t* sys_ctx,const
 Uapi_ExpWin_t* ExpWin);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.6.15 rk_aiq_user_api2_ae_queryExpResInfo

【Description】 Obtain AE internal state information.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_ae_queryExpResInfo(const rk_aiq_sys_ctx_t* ctx,
 Uapi_ExpQueryInfo_t* pExpResInfo);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Library file: librkaiq.so

6.7 Module-level API data types

6.7.1 Uapi_ExpSwAttr_t

【Description】

AE common function control parameter structure.

【Definition】

 typedef struct Uapi_ExpSwAttrV2_s {
     rk_aiq_uapi_sync_t                 sync;
     uint8_t                            Enable;
     CalibDb_CamRawStatsModeV2_t        RawStatsMode;
     CalibDb_CamHistStatsModeV2_t       HistStatsMode;
     CalibDb_CamYRangeModeV2_t          YRangeMode;
     uint8_t                            AecRunInterval;
     RKAiqOPMode_t                      AecOpType;
     Cam15x15UCharMatrix_t              GridWeights;
     Uapi_AeAttrV2_t                    stAuto;
     Uapi_MeAttrV2_t                    stManual;
     Uapi_ExpSwAttr_AdvancedV2_t        stAdvanced;
 } Uapi_ExpSwAttrV2_t;

【Member】

Related Data Type

rk_aiq_uapi_sync_t

Uapi_ExpSwAttr_AdvancedV2_t

Uapi_AeAttrV2_t

Uapi_MeAttrV2_t

6.7.1.1 Uapi_ExpSwAttr_AdvancedV2_t

【Description】

Parameter structs are preferred.

【Definition】

 typedef struct Aec_uapi_advanced_attr_s {
     bool                          enable;
     uint8_t                       GridWeights[15 * 15];
     bool                          SetAeRangeEn;
     Aec_LinAeRange_t              SetLinAeRange;
     Aec_HdrAeRange_t              SetHdrAeRange;
 } Aec_uapi_advanced_attr_t;
 typedef Aec_uapi_advanced_attr_t Uapi_ExpSwAttr_AdvancedV2_t;

【Member】

【Precautions】

Uapi_ExpSwAttrV2_t A set of AE weights is defined in the structure, and the number of weights is 15X15. The algorithm expands the weights according to the actual number of weights configured by the hardware. If you need to expose a similar face, you can use a set of AE weights defined in the Uapi_ExpSwAttr_AdvancedV2_t, and the number of weights is 15X15. The algorithm compresses the weights according to the actual number of weights configured by the hardware. If you want to use a set of AE weights defined in the Uapi_ExpSwAttr_Advanced_t, enable must be enabled and set to 1.

When setting the AE parameter range through the API, you need to set SetAeRangeEn to 1, otherwise the automatic exposure parameter range in the debug file is used by default. The setting of the exposure parameter range is divided into two sets: SetLinAeRange and SetHdrAeRange according to different exposure modes. Among them, SetHdrAeRange supports setting the range of auto exposure parameters for each frame. In addition, the final effective exposure time and gain range need to be queried in the stAuto structure, where only the set range, not the final effective range.

6.7.1.1.1 Aec_AeRange_t

【Description】 Define the AE parameter range.

【Definition】

 typedef struct Aec_AeRange_s {
     float                   Min;
     float                   Max;
 } Aec_AeRange_t;

【Member】

6.7.1.1.2 Aec_LinAeRange_t

【Description】 Define the parameter range for AE linear mode.

【Definition】

 typedef struct Aec_LinAeRange_s {
     Aec_AeRange_t      stExpTimeRange;
     Aec_AeRange_t      stGainRange;
     Aec_AeRange_t      stIspDGainRange;
     Aec_AeRange_t      stPIrisRange;
 } Aec_LinAeRange_t;

【Member】

【Precautions】

When the maximum/minimum value of each exposure component is the default value of 0, the set exposure component range does not take effect, and the actual maximum/minimum value of each exposure component is determined by the minimum and maximum values of the AecRoute exposure decomposition route node.

When the maximum/minimum value of each exposure component is not 0, the set exposure component range takes effect, when the set exposure component range does not exceed the limit of sensor or ISP, the actual maximum/minimum value of each exposure component is subject to the set exposure component range, and the AecRoute exposure decomposition route is corrected, and the node maximum/minimum value is changed to the set maximum / minimum value of the exposure component; If the limit of sensor or ISP is exceeded, the actual maximum/minimum value of each exposure component is subject to the maximum and minimum values of the AecRoute exposure decomposition route node

6.7.1.1.3 Aec_HdrAeRange_t

【Description】 Define the parameter range for AE HDR mode.

【Definition】

 typedef struct Aec_HdrAeRange_s {
     Aec_AeRange_t      stExpTimeRange[3];
     Aec_AeRange_t      stGainRange[3];
     Aec_AeRange_t      stIspDGainRange[3];
     Aec_AeRange_t      stPIrisRange;
 } Aec_HdrAeRange_t;

【Member】

【Precautions】

stExpTimeRange, stGainRange, stIspDGainRange are predefined as arrays with 3 members. In the 2-frame HDR mode, only members 0 and 1 are valid, indicating the exposure component ranges corresponding to short frames and long frames, respectively. In 3-frame HDR mode, 0-2 is valid, indicating the exposure component range corresponding to short, medium, and long frames, respectively.

When the maximum/minimum value of each exposure component is the default value of 0, the set exposure component range does not take effect, and the actual maximum/minimum value of each exposure component is determined by the minimum and maximum values of the exposure decomposition route node corrected by the algorithm.

When the maximum / minimum value of each exposure component is not 0, the set exposure component range takes effect, when the set exposure component range does not exceed the limit of sensor or ISP, the actual maximum / minimum value of each exposure component is subject to the set exposure component range, and the exposure decomposition route is corrected, and the node maximum/minimum value is changed to the set maximum / minimum value of the exposure component; If the limit of sensor or ISP is

exceeded, the actual maximum/minimum value of each exposure component is subject to the maximum and minimum values of the exposure decomposition route node. The 1106 platform does not support the isp dgain function at the moment, so stIspDGainRange is temporarily invalid

6.7.1.2 Uapi_AeAttrV2_t

【Description】 Define AE auto exposure properties.

【Definition】

 typedef struct Uapi_AeAttrV2_s {
     Uapi_AeSpeedV2_t           stAeSpeed;
     DelayFrmNum
     uint8_t                    BlackDelayFrame;
     uint8_t                    WhiteDelayFrame;
     Auto/Fixed fps
     Uapi_AeFpsAttrV2_t         stFrmRate;
     Uapi_AntiFlickerV2_t       stAntiFlicker;
     auto range
     Aec_LinAeRange_t           LinAeRange;//result LinAerange
     Aec_HdrAeRange_t           HdrAeRange;//result HdrAerange
 } Uapi_AeAttrV2_t;

【Member】

【Precautions】

LinAeRange/HdrAeRange is the range of parameters actually used after verification correction inside the algorithm. When the AE parameter range set by the API exceeds the parameter range limited by the sensor, the parameter range limited by the sensor will be used. The range of parameters limited by sensor can be found in the AE module sensorinfo parameter in the Rockchip_Tuning_Guide_ISP30_CN.pdf documentation.

To set the auto exposure component range, the API calls the parameter in the Uapi_ExpSwAttr_AdvancedV2_t above and sets SetAeRangeEn to 1, otherwise the auto exposure parameter range in the debug file is used by default.

6.7.1.2.1 Uapi_AeSpeedV2_t

【Description】 Define AE conditional speed properties.

【Definition】

 typedef struct CalibDb_AeSpeedV2_s {
     float                   DampOver;
     float                   DampUnder;
     float                   DampDark2Bright;
     float                   DampBright2Dark;
 } CalibDb_AeSpeedV2_t;
 typedef CalibDb_AeSpeedV2_t Uapi_AeSpeedV2_t;

【Member】

6.7.1.2.2 Uapi_AeFpsAttrV2_t

【Description】 Define AE frame rate properties.

【Definition】

 typedef struct CalibDb_AeFrmRateAttrV2_s {
     bool             isFpsFix;
     uint8_t          FpsValue;
 } CalibDb_AeFrmRateAttrV2_t;
 typedef CalibDb_AeFrmRateAttrV2_t Uapi_AeFpsAttrV2_t;

【Member】

6.7.1.2.3 Uapi_AntiFlickerV2_t

【Description】 Define anti-flash properties.

【Definition】

 typedef struct CalibDb_AntiFlickerAttrV2_s {
     bool                           enable;
     CalibDb_FlickerFreq_t          Frequency;
     CalibDb_AntiFlickerMode_t      Mode;
 } CalibDb_AntiFlickerAttrV2_t;
 typedef CalibDb_AntiFlickerAttrV2_t Uapi_AntiFlickerV2_t;

【Member】

【Precautions】

To turn off the anti-flash function, you need to set the enable bit enable to 0, and the algorithm automatically configures Frequency=AECV2_FLICKER_FREQUENCY_OFF; If the anti-flash enable bit is set to 1, the anti-flash frequency is configured to AECV2_FLICKER_FREQUENCY_OFF, the frequency value will be invalid, and the default value will be used to AECV2_FLICKER_FREQUENCY_50HZ.

AECV2_ANTIFLICKER_NORMAL_MODE normal anti-flash mode, the exposure time can be adjusted according to the brightness, and the minimum exposure time is fixed at 1/120 sec (60Hz) or 1/100 sec (50Hz), not limited by the minimum exposure time.

Illuminated environment: The exposure time can be matched to the frequency of the light source, which prevents the image from flickering.

High brightness environment: The higher the brightness, the shortest exposure time required. The minimum exposure time of the normal anti-flash mode cannot match the frequency of the light source, resulting in overexposure. AECV2_ANTIFLICKER_AUTO_MODE is an automatic anti-flash mode, the exposure time can be adjusted according to the brightness, and the minimum exposure time can reach the minimum exposure time of the sensor. The difference from the normal anti-flash mode is mainly reflected in the high brightness environment. High brightness environment: The minimum exposure time can reach the minimum exposure time of the sensor, which can effectively suppress overexposure, but the anti-flash fails at this time.

6.7.1.3 Uapi_MeAttrV2_t

【Description】

Manual exposure parameter setting, according to the exposure mode is divided into LinearAE and HdrAE two sets of parameters.

【Definition】

 typedef struct Uapi_MeAttrV2_s {
     Uapi_LinMeAttrV2_t     stLinMe;
     Uapi_HdrMeAttrV2_t     stHdrMe;
 } Uapi_MeAttrV2_t;

【Related data types】

Uapi_LinMeAttrV2_t

Uapi_HdrMeAttrV2_t

6.7.1.3.1 Uapi_LinMeAttrV2_t

【Description】

Manual exposure control parameters for LinearAE.

【Definition】

 typedef struct Uapi_LinMeAttrV2_s {
     bool                 ManualTimeEn;
     bool                 ManualGainEn;
     bool                 ManualIspDgainEn;
     float                TimeValue;
     float                GainValue;
     float                IspDGainValue;
 } Uapi_LinMeAttrV2_t;

【Member】

【Precautions】

This module parameter is only valid when AeOptype = MANUAL. ManualTimeEn, ManualGainEn, ManualIspDgainEn are all 1, which is manual mode; As long as any of the above three is not enabled, it is semi-automatic mode; If all four of the above are 0, it is equivalent to automatic mode, and the system will report an error reminder.

In manual/semi-manual mode, the manual exposure time and gain are limited by the maximum/minimum exposure time and gain in automatic mode. After the auto exposure limit is exceeded, the maximum/minimum value in auto mode is used instead.

RK356X does not support ISP digital gain, so ManualIspDgainEn and IspDGainValue are invalid.

6.7.1.3.2 Uapi_HdrMeAttrV2_t

【Description】

Manual exposure control parameters for HdrAE.

【Definition】

 typedef struct Uapi_HdrMeAttrV2_s {
     bool                    ManualTimeEn;
     bool                    ManualGainEn;
     bool                    ManualIspDgainEn;
     Cam3x1FloatMatrix_t     TimeValue;
     Cam3x1FloatMatrix_t     GainValue;
     Cam3x1FloatMatrix_t     IspDGainValue;
 } Uapi_HdrMeAttrV2_t;

【Member】

Variables have the same meaning as Uapi_LinMeAttrV2_t.

【Precautions】

TimeValue/GainValue/IspDGainValue are arrays with 3 members. In HDR 2 frame mode, the array [0-1] members are valid, representing short and long frames, respectively; In HDR 3 frame mode, the array [0-2] members are valid, corresponding to short, medium, and long frames, respectively.

In manual/semi-manual mode, the manual exposure time and gain are limited by the maximum/minimum exposure time and gain in automatic mode. After the auto exposure limit is exceeded, the maximum/minimum value in auto mode is used instead.

RK356X does not currently support ISP digital gain, so ManualIspDgainEn, IspDGainValue are invalid.

6.7.2 Uapi_LinAeRouteAttr_t

【Description】 Define AE linear exposure decomposition path properties.

【Definition】

 typedef struct CalibDb_LinAeRoute_AttrV2_s {
     float* TimeDot;
     int TimeDot_len;
     float* GainDot;
     int GainDot_len;
     float* IspDGainDot;
     int IspDGainDot_len;
     int* PIrisDot;
     int PIrisDot_len;
 } CalibDb_LinAeRoute_AttrV2_t;
 typedef struct Uapi_LinAeRouteAttr_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_LinAeRoute_AttrV2_t   Params;
 } Uapi_LinAeRouteAttr_t;

【Member】

【Precautions】

There is no limit to the number of exposure decomposition curve nodes, but it is recommended not to have less than 6.

The exposure of a node is the product of each component such as exposure time, sensor gain, ISP digital gain, and aperture equivalent gain. The exposure of the node must be monotonically increasing, that is, the exposure of the latter node must be greater than the exposure of the previous node. The first node has the least exposure and the second node has the largest exposure.

The exposure time component in the node is in seconds, the minimum value is allowed to be 0, and the actual minimum exposure time code is internally corrected according to the sensor limit.

Aperture component only supports P-Iris, DC-Iris is not supported. The P-iris equivalent gain component is only valid when the Airis auto iris function is enabled, otherwise the default aperture is fixed to the initial value size. The calculation of the equivalent gain of P-iris is detailed in the AecIrisCtrl module.

The set exposure decomposition route node is not the final exposure decomposition route. The actual maximum/small value of each final exposure component of the system is determined by the combination of the exposure decomposition node and the manually configured exposure component maximum/small value. First make the first correction of the maximum/small value of the node of the exposure decomposition route,

and when the maximum/small value of the node does not exceed the limit of SENSOR or ISP, the maximum/small value of the node remains unchanged; When the node maximum/small value exceeds the limit of the sensor or ISP, the node maximum/small value is subject to the limit of the sensor or ISP. When the maximum/minimum value of the manually configured exposure component is 0, the final effective exposure decomposition route is subject to the decomposition route of the first correction; When the maximum/small value of the manually configured exposure component is not 0, and the maximum/small value set does not exceed the limit of SENSOR or ISP, the exposure decomposition route is corrected for the second time, and the node maximum/small value is subject to the manually set range; If the maximum/small value of the exposure component is set beyond the limit of the sensor or ISP, the node maximum/small value of the exposure component of the exposure decomposition route shall be subject to the result of the first correction. If the exposure of adjacent nodes increases, only one exposure component should increase and the others fixed. The added component determines the allocation strategy for that segment of the route. For example, if the gain component increases and the other components are fixed, then the distribution strategy of this segment of the route is gain first.

RK356X does not currently support ISP digital gain, so IspgainDot is invalid.

6.7.3 Uapi_HdrAeRouteAttr_t

【Description】 Define AE HDR exposure decomposition path properties.

【Definition】

 typedef struct CalibDb_HdrAeRoute_AttrV2_s {
     float* Frm0TimeDot;
     int Frm0TimeDot_len;
     float* Frm0GainDot;
     int Frm0GainDot_len;
     float* Frm0IspDGainDot;
     int Frm0IspDGainDot_len;
     float* Frm1TimeDot;
     int Frm1TimeDot_len;
     float* Frm1GainDot;
     int Frm1GainDot_len;
     float* Frm1IspDGainDot;
     int Frm1IspDGainDot_len;
     float* Frm2TimeDot;
     int Frm2TimeDot_len;
     float* Frm2GainDot;
     int Frm2GainDot_len;
     float* Frm2IspDGainDot;
     int Frm2IspDGainDot_len;
     int* PIrisDot;
     int PIrisDot_len;
 } CalibDb_HdrAeRoute_AttV2r_t;
 typedef struct Uapi_HdrAeRouteAttr_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_HdrAeRoute_AttrV2_t   Params;
 } Uapi_HdrAeRouteAttr_t;

【Members】

【Precautions】

The number of exposure decomposition curve nodes is not limited, It is recommended to set at least 6 nodes to achieve smooth exposure decomposition.

It should be noted that in HDR 2 frame mode, only Frm0/1TimeDot, Frm0/1GainDot, Frm0/1IspDGainDot need to be set, corresponding to the actual short and long frames respectively; In HDR 3 frame mode, Frm0/1/2TimeDot, Frm0/1/2GainDot, Frm0/1/2IspDGainDot need to be set, corresponding to short, medium and long frames respectively. When setting the sensor exposure time for each frame in HDR mode, you need to allocate the exposure time reasonably, and the sum of the exposure time of each frame ** cannot exceed the maximum exposure time allowed by the frame rate**!

The exposure of a node is the product of each component such as exposure time, sensor gain, ISP digital gain, and aperture equivalent gain. The exposure of the node must be monotonically increasing, that is, the exposure of the latter node must be greater than the exposure of the previous node. The first node has the least exposure and the second node has the largest exposure.

The exposure time component in the node is in seconds, the minimum value is allowed to be 0, and the actual minimum exposure time code is internally corrected according to the sensor limit.

Aperture component only supports P-Iris, DC-Iris is not supported. The P-iris equivalent gain component is only valid when the Airis auto iris function is enabled, otherwise the default aperture is fixed to the initial value size. The calculation of the equivalent gain of P-iris is detailed in the AecIrisCtrl module.

The set exposure decomposition route node is not the final exposure decomposition route. The actual maximum/small value of each final exposure component of the system is determined by the combination of the exposure decomposition node and the manually configured exposure component maximum/small value. First make the first correction of the maximum/small value of the node of the exposure decomposition route, and when the maximum/small value of the node does not exceed the limit of SENSOR or ISP, the maximum/small value of the node remains unchanged; When the node maximum/small value exceeds the limit of the sensor or ISP, the node maximum/small value is subject to the limit of the sensor or ISP. When the maximum/minimum value of the manually configured exposure component is 0, the final effective exposure decomposition route is subject to the decomposition route of the first correction; When the maximum/small value of the manually configured exposure component is not 0, and the maximum/small value set does not exceed the limit of SENSOR or ISP, the exposure decomposition route is corrected for the

second time, and the node maximum/small value is subject to the manually set range; If the maximum/small value of the exposure component is set beyond the limit of the sensor or ISP, the node maximum/small value of the exposure component of the exposure decomposition route shall be subject to the result of the first correction. If the exposure of adjacent nodes increases, only one exposure component should increase and the others fixed. The added component determines the allocation strategy for that segment of the route. For example, if the gain component increases and the other components are fixed, then the distribution strategy of this segment of the route is gain first.

356X does not currently support ISP digital gain, so Frm0/1/2ispDGainDot are invalid.

6.7.4 Uapi_LinExpAttrV2_t

【Description】

Define AE linear exposure tuning parameters.

【Definition】

 typedef struct CalibDb_LinearAE_AttrV2_s {
     uint8_t RawStatsEn;
     float ToleranceIn;
     float ToleranceOut;
     float Evbias;
     CalibDb_AeStrategyModeV2_t      StrategyMode;
     CalibDb_LinExpInitExpV2_t       InitExp;
     CalibDb_LinAeRoute_AttrV2_t     Route;
     CalibDb_AecDynamicSetpointV2_t  DySetpoint;
     CalibDb_AecBacklightV2_t        BackLightCtrl;
     CalibDb_AecOverExpCtrlV2_t OverExpCtrl;
 } CalibDb_LinearAE_AttrV2_t;
 typedef struct Uapi_LinExpAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_LinearAE_AttrV2_t     Params;
 } Uapi_LinExpAttrV2_t;

【Member】

【Precautions】

EvBias for fine-tuning (SetPoint/IRSetPoint) of target luminance values (fixed/dynamic) in special scenarios. The true effective target brightness is (SetPoint)*[1+abs(EvBias)/100]^[EvBias/abs(EvBias)]. If EvBias=100 is set, the target brightness is twice the default parameter. When EvBias=-100, the target brightness is 1/2 of the default parameter.

The tolerance of the brightness of the AE screen is Tolerance, and when the AE converges, the brightness value B should be within the range of [True Effective Target Brightness X(1-Tolerance/100), True Effective Target Luminance X(1+Tolerance/100)]. The ToleranceIn/Out setting is large, which will affect the response speed of AE on the one hand, and the EvBias value on the other. When the interval value of EvBias adjustment is lower than ToleranceIn/Out, it may cause the brightness adjustment to not take effect.

StrategyMode is currently invalid.

【Related data types】

CalibDb_AecDynamicSetpointV2_t

CalibDb_AecBacklightV2_t

CalibDb_AecOverExpCtrlV2_t

6.7.4.1 CalibDb_AecDynamicSetpointV2_t

【Description】 Define AE dynamic target values.

【Definition】

 typedef struct CalibDb_AecDynamicSetpointV2_s {
     float* ExpLevel;
     int ExpLevel_len;
     float* DySetpoint;
     int DySetpoint_len;
 } CalibDb_AecDynamicSetpointV2_t;

【Member】

6.7.5 Uapi_HdrExpAttrV2_t

【Description】 Define AE HDR exposure debug parameters.

【Definition】

 typedef struct CalibDb_HdrAE_AttrV2_s {
     float ToleranceIn;
     float ToleranceOut;
     float Evbias;
     CalibDb_AeStrategyModeV2_t StrategyMode;
     float LumaDistTh; //used for area-growing
     CalibDb_HdrExpInitExpV2_t InitExp;
     CalibDb_HdrAeRoute_AttrV2_t Route;
     CalibDb_ExpRatioCtrlV2_t ExpRatioCtrl;
     CalibDb_LongFrmCtrlV2_t LongFrmMode;
     CalibDb_LfrmCtrlV2_t LframeCtrl;
     CalibDb_MfrmCtrlV2_t MframeCtrl;
     CalibDb_SfrmCtrlV2_t SframeCtrl;
 } CalibDb_HdrAE_AttrV2_t;
 typedef struct Uapi_HdrExpAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_HdrAE_AttrV2_t        Params;
 } Uapi_HdrExpAttrV2_t;

【Member】

【Related data types】

CalibDb_LFrameCtrlV2_t

CalibDb_MFrameCtrlV2_t

CalibDb_SFrameCtrlV2_t

6.7.6 Uapi_IrisAttrV2_t

【Description】

Aperture control parameters.

【Definition】

 typedef struct CalibDb_AecIrisCtrlV2_s {
     uint8_t Enable;
     CalibDb_IrisTypeV2_t IrisType;
     RKAiqOPMode_t IrisOpType;
     CalibDb_MIris_AttrV2_t ManualAttr;
     CalibDb_PIris_AttrV2_t PIrisAttr;
     CalibDb_DCIris_AttrV2_t DCIrisAttr;
 } CalibDb_AecIrisCtrlV2_t;
 typedef struct Uapi_IrisAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_AecIrisCtrlV2_t       Params;
 } Uapi_IrisAttrV2_t;

【Member】

6.7.6.1 CalibDb_MIris_AttrV2_t

【Description】

Manual aperture parameters.

【Definition】

 typedef struct CalibDb_MIris_AttrV2_s {
     int PIrisGainValue;
     int DCIrisHoldValue;
 } CalibDb_MIris_AttrV2_t;

【Member】

【Precautions】

IrisOpType = RK_AIQ_OP_MODE_MANUAL, manual aperture enabled. When the aperture type is P- aperture, only PirisGainValue is valid; When the aperture type is DC aperture, only DCIrisHoldValue is valid.

DCIrisHoldValue, directly set the PWM duty cycle value of the motor in manual mode, the value range [0,100]. If the HoldValue value is set in manual mode (that is, the value in the range from ClosePwmDuty to OpenPwmDuty in AecIrisCtrl), the DC aperture aperture remains at the current size; If the value set is greater than OpenPwmDuty, the aperture is turned on, and the larger the value, the greater the opening speed; If the value set is less than ClosePwmDuty, the aperture is off, and the smaller the value, the greater the speed of closing.

6.7.6.2 CalibDb_PIris_AttrV2_t

【Description】

P aperture attribute parameter.

【Definition】

 #define AEC_PIRIS_STAP_TABLE_MAX (1024)
 typedef struct CalibDb_PIris_AttrV2_s {
     uint16_t              TotalStep;
     uint16_t              EffcStep;
     bool                  ZeroIsMax;
     uint16_t              StepTable[AEC_PIRIS_STAP_TABLE_MAX];
 } CalibDb_PIris_AttrV2_t;

【Member】

6.7.6.3 CalibDb_DCIris_AttrV2_t

【Description】

DC aperture property.

【Definition】

 typedef struct CalibDb_DCIris_AttrV2_s {
     float       Kp;
     float       Ki;
     float       Kd;
     int         MinPwmDuty;
     int         MaxPwmDuty;
     int         OpenPwmDuty;
     int         ClosePwmDuty;
 } CalibDb_DCIris_AttrV2_t;

【Member】

【Precautions】

When the auto iris function is turned off, for DC-iris aperture, it will be turned on to the maximum by default; For the P-iris aperture, the stepper motor position corresponding to the maximum aperture is turned on by default. If you want to change the above aperture position, you can modify InitPIrisGainValue and InitDCIrisDutyValue in the AecInitValue module.

The basic control flow of the automatic iris Airis algorithm is as follows:

For DC-iris lenses, Airis controls the aperture size of the DC-iris lens based on the deviation of the current brightness from the target brightness. When the exposure reaches the minimum value, and the current brightness exceeds the target brightness tolerance range, the AE control will be exited, and the exposure time and exposure gain will be fixed and enter the AIRIS control range. If the current screen brightness is stable and the PWM duty

of DC-iris is greater than OpenPwmDuty, the current aperture is considered to have reached the maximum, and the Airis aperture control is withdrawn, and the control is handed over to AE.

For P-iris lenses, aperture control is performed via the AecRoute module. The aperture size of the P-iris lens is converted to the equivalent gain and participates in the exposure decomposition calculation.

P-iris stepper motor position and aperture equivalent gain mapping table StepTable is generally made according to the correspondence between stepper motor position and aperture aperture provided by lens manufacturers. The control of P-iris is controlled by AE’s AecRoute module, which converts the aperture aperture size into equivalent gain, so P-iris control needs to have good linearity. The equivalent gain ranges from [1,1024], with an equivalent gain of 1024 for F1.0, an equivalent gain of 512 for F1.4, and so on, an equivalent gain of 1 for F32.0. When making a table, it is necessary to convert the aperture aperture corresponding to the stepper motor position to the equivalent gain, fill it in the StepTable, and fix it to increment according to the stepper motor position (i.e. step0, step1…). stepN).

TotalStep represents the total number of steps of the P-iris stepper motor, and the specific size is related to the P-iris lens. EffcStep indicates the number of steps available for P-iris stepper motors, which is generally less than TotalStep. Because the position near the closed end of the aperture has a large error in the value corresponding to the equivalent gain, and oscillations are prone to occur during iris adjustment, the step position near the closed end of the aperture is usually not used.

Table 4-1 is a table corresponding to the position of the P-iris stepper motor to the aperture aperture and equivalent gain, and use this table as an example to illustrate how to set the StepTable. The correspondence between the stepper motor position step and the aperture aperture area in columns 1-2 and 4-5 in Table 4-1 is provided by a lens manufacturer. The P-iris lens has a stepper motor adjustment total of 81 steps, with the largest aperture aperture at step0 and a nominal maximum aperture of 1.4. A number of apertures of 1.4 corresponds to an equivalent gain of 512, so the equivalent gain at step 0 is 512. The equivalent gain corresponding to the other aperture areas, here taking step 3 as an example, is calculated as follows: the aperture area of step 3 is 195.869, and the corresponding equivalent gain = 512* (195.869/201.062)=499(rounded). By analogy, the equivalent gain values corresponding to the positions of other stepper motors can also be calculated from this. It can be seen from Table 1-1 that when the stepper motor position is close to the closed end, the corresponding aperture area is very small, and the difference from the largest aperture area can be thousands of times, and the corresponding equivalent gain value error is large, so it is recommended that the stepper motor position close to the closed end of the aperture should not be used, so as not to cause exposure oscillation due to errors. The equivalent gain corresponding to each stepper motor position in the table is incremented according to the stepper motor position (i.e., step0, step1…). stepN) is filled in the StepTable.

DC-iris’ OpenPwmDuty and ClosePwmDuty values need to be measured and are related to DC-iris lenses. For some lenses, when the PWM duty cycle is greater than OpenPwmDuty, the aperture performs an open operation; When the PWM duty cycle is less than OpenPwmDuty, the aperture performs a closed operation; When the PWM duty cycle is greater than or equal to ClosePwmDuty and less than or equal to OpenPwmDuty, the aperture is stable at the current position, and the values in this interval are HoldValue. In addition, there are some lenses, and there is only a threshold of the aperture switch, that is, when the PWM duty cycle is greater than this threshold, the aperture performs an open operation; When the PWM duty cycle is less than this threshold, the aperture performs a off operation; When the PWM duty cycle is equal to this threshold, the aperture stabilizes at the current position, which is HoldValue. In this case, you can make ClosePwmDuty = OpenPwmDuty = HoldValue.

The manual mode parameter setting of the aperture is consistent with the manual mode of exposure. When you need to use the manual iris function, set the AecOpType to manual mode and enable the ManualIrisEn parameter in the AecManualCtrl module. When IrisType is P-iris, only PirisGainValue is valid; When IrisType is P-iris, only DCIrisValue is valid.

Table 4-1 P-iris stepper motor position and aperture aperture and equivalent gain correspondence table

6.7.7 Uapi_ExpWin_t

【Description】 Define AE Statistics Window Properties parameters.

【Definition】

 typedef struct window {
     uint16_t h_offs;
     uint16_t v_offs;
     uint16_t h_size;
     uint16_t v_size;
 } window_t;
 typedef struct Uapi_ExpWin_s {
   rk_aiq_uapi_sync_t            sync;
   window                        Params;
 } Uapi_ExpWin_t;

【Member】

6.7.8 Uapi_ExpQueryInfo_t

【Description】 Define AE exposure parameter queries.

【Definition】

 typedef struct Uapi_ExpQueryInfo_s {
     bool              IsConverged;
     bool              IsExpMax;
     float             LumaDeviation;
     float             HdrLumaDeviation[3];
     float             MeanLuma;
     float             HdrMeanLuma[3];
     float             GlobalEnvLux;
     float             BlockEnvLux[ISP2_RAWAE_WINNUM_MAX];
     RKAiqAecExpInfo_t CurExpInfo;
     unsigned short    Piris;
     float             LinePeriodsPerField;
     float             PixelPeriodsPerLine;
     float             PixelClockFreqMHZ;
 } Uapi_ExpQueryInfo_t;

【Member】

6.8 Common problem location and debug method

If problems such as screen brightness flicker, overshoot, or brightness not meeting expectations occur, it is recommended to capture the AE LOG of the problematic scene for analysis, which can help quickly locate the problem and improve work efficiency.

6.8.1 Exposure statistics synchronous test function

Before calibrating the ISP module, the driver or tuning personnel need to fill in the SensorInfo parameter in the debugging IQ XML. This module involves the setting of exposure parameters, such as incorrect settings may cause exposure errors, flickering and other phenomena. It is recommended that after configuring the sensorinfo parameter, enable the SyncTest function for self-testing. SensorInfo parameter meaning description refer to Rockchip_Tuning_Guide_ISP30.

The SyncTest function can test whether the exposure time and exposure gain of the sensor, and the effective frame number of DCG switching are correct by cyclically setting N groups of different exposure values, and can also be used to test the linearity of the exposure, so as to confirm whether the register value conversion formula and related parameters of the exposure time and exposure gain are correct.

The SyncTest function parameters are described as follows:

【Description】

The synchronous test function of exposure and statistics supports cyclic setting of N groups of different exposure values according to the number of frames at a given interval, which is used to debug and verify whether the effective frame number of exposure components (exposure time, exposure gain) and sensor exposure parameter settings are correct.

【Member】

AlterExp

According to the different modes, it is divided into two sets of parameters: LinearAE and HdrAE.

If the parameters are set correctly, the following example is used for LOG (only the key information in LOG is intercepted). The red frame shows the exposure switching position, the visible brightness has not changed and matches the exposure value, there is no delay or advance linearity, at this time, it can be basically judged that the sensorinfo parameter is set correctly.

6.8.2 Flickering occurs when exposure changes

There are several reasons why flicker can occur when exposure changes:

(1) The frame number of the gain and time effective moments in the CISExpUpdate module is wrong. Examples of common LOGS are as follows (only key LOG lines per frame are intercepted):

The red frame is marked with the brightness error position, and it can be seen that as the exposure increases or decreases, the corresponding brightness is opposite to the exposure change trend. By observation, it can be seen that the sudden change in luminance occurs in the second frame after both the exposure time and exposure gain change. The change trend of brightness is consistent with the trend of exposure time, so it can be judged that the effective frame number of gain and time is wrong, and the change of exposure time and exposure gain does not take effect at the same time, resulting in a mismatch between brightness and exposure. You can solve this problem by modifying the number of frames in gain and time. The above problems can be reproduced using AE’s syncTest

function, setting two sets of exposures (different exposure gain and exposure time), and making them switch back and forth to see if the LOG can know if it is reproduced.

(2) The brightness oscillation back and forth caused by driving errors cannot converge, often occurs in highlight scenes, common LOG examples are as follows (only intercept the key LOG line of each frame)

As shown in the figure, it can be observed that the exposure oscillates back and forth between 59ms and 44ms, and looking at the corresponding brightness average of 59ms and 44ms, it will be found that the ratio of brightness and the ratio of exposure of the two has a large gap, and there is a problem with linearity. The first step requires the sensor’s drive detection, where the exposure register value is printed to see if the register value is consistent with the exposure in the log. The above problem can be reproduced using AE’s syncTest function, setting multiple sets of exposures (including the one in question), making them switch back and forth to see if the brightness change corresponding to each frame of exposure in LOG is linear.

(3) Flickering caused by AE subsequent modules, common LOG examples are as follows (only intercept the key LOG lines of each frame):

From LOG, it can be seen that during the decline of SMeanLuma and MMeanLuma on the left, the brightness of the output of the TmoMeanluma module has changed, and when this happens, it is necessary to debug the TMO module.

7. AWB

7.1 Overview

The function of the AWB module is to uniformly compensate for the color deviation caused by the color temperature environment and the deviation of the inherent color channel gain of the shooting equipment by changing the gain of the color channel of the shooting equipment, so that the obtained image can correctly reflect the true color of the object.

7.2 Important concepts

Color temperature: The color temperature is defined by the absolute black body, and when the radiation of the light source is exactly the same as the radiation of the absolute black body in the visible area, the temperature of the black body is called the color temperature of the light source.

White balance: Under light sources with different color temperatures, the response of white in the sensor will be bluish or reddish. The white balance algorithm adjusts the intensity of the three color channels R, G, and B to make white appear realistically.

7.3 Description of the feature

The AWB module consists of two parts: WB information statistics and AWB policy control algorithm.

7.4 Feature-level API reference

7.4.1 rk_aiq_uapi2_setWBMode

【Description】 Set the white balance operating mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_setWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameters】

【Return Value】

【Note】

If set to manual mode, the white balance gain value is controlled by the current manual white balance parameter. If you need to switch manual mode while setting a specific gain value, you can use the rk_aiq_uapi2_setMWBGain interface.

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.2 rk_aiq_uapi2_getWBMode

【Description】 Gets the white balance operating mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_getWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.3 rk_aiq_uapi2_lockAWB

【Description】 Locks the current white balance parameters.

【Grammar】

 XCamReturn rk_aiq_uapi2_lockAWB(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.4 rk_aiq_uapi2_unlockAWB

【Description】 Unlock locked white balance parameters.

【Grammar】

 XCamReturn rk_aiq_uapi2_unlockAWB(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.5 rk_aiq_uapi2_setMWBScene

【Description】 Set the white balance scene.

【Grammar】

 XCamReturn rk_aiq_uapi2_setMWBScene(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_wb_scene_t scene);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.6 rk_aiq_uapi2_getMWBScene

【Description】 Get the white balance scene.

【Grammar】

 XCamReturn rk_aiq_uapi2_getMWBScene(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_wb_scene_t *scene);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.7 rk_aiq_uapi2_setMWBGain

【Description】 Set the manual white balance gain factor.

【Grammar】

 XCamReturn rk_aiq_uapi2_setMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t
 *gain);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.8 rk_aiq_uapi2_getWBGain

【Description】 Gets the white balance gain factor. This function is used for both manual and auto white balance

【Grammar】

 XCamReturn rk_aiq_uapi2_getWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t
 *gain);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.9 rk_aiq_uapi2_setMWBCT

【Description】 Set the manual white balance color temperature parameter.

【Grammar】

 XCamReturn rk_aiq_uapi2_setMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int ct);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.10 rk_aiq_uapi2_getWBCT

【Description】 Get the white balance color temperature. This function is used both automatically and manually

【Grammar】

 XCamReturn rk_aiq_uapi2_getWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int *ct);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.11 rk_aiq_uapi2_setAwbGainOffsetAttrib

【Description】 Sets the offset of the auto white balance gain.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.12 rk_aiq_uapi2_getAwbGainOffsetAttrib

【Description】 Gets the offset of the auto white balance gain

【Grammar】

 XCamReturn rk_aiq_uapi2_getAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx,
 CalibDbV2_Awb_gain_offset_cfg_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.13 rk_aiq_uapi2_setAwbGainAdjustAttrib

【Description】 Sets the tone adjustment parameters in auto white balance mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.14 rk_aiq_uapi2_getAwbGainAdjustAttrib

【Description】 Gets the tone adjustment parameters in auto white balance mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_getAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.4.15 rk_aiq_uapi2_setAwbV30AllAttrib

【Description】 Set all parameters supported by the White Balance API.

【Grammar】

 XCamReturn rk_aiq_uapi2_setAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wbV30_attrib_t attr);

【Parameter】

【Return value】

【Demand】

Header files:rk_aiq_user_api2_imgproc.h

Library files:librkaiq.so

【Example】

Refer to sample_awb_module.cpp

7.4.16 rk_aiq_uapi2_getAwbV30AllAttrib

【Description】 Get all the parameters supported by the White Balance API.

【Grammar】

 XCamReturn rk_aiq_uapi2_getAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wbV30_attrib_t *attr);

【Parameter】

【Return value】

【Demand】

Header files:rk_aiq_user_api2_imgproc.h

Library files:librkaiq.so

【Example】

Refer to sample_awb_module.cpp

7.5 Functional-level API data types

7.5.1 rk_aiq_wb_op_mode_t

【Description】 Defines the white balance operating mode

【Definition】

 typedef enum rk_aiq_wb_op_mode_s {
     RK_AIQ_WB_MODE_INVALID        = 0,
     RK_AIQ_WB_MODE_MANUAL         = 1,
     RK_AIQ_WB_MODE_AUTO           = 2,
     RK_AIQ_WB_MODE_MAX
 } rk_aiq_wb_op_mode_t;

【Member】

7.5.2 rk_aiq_wb_mwb_mode_t

【Description】 Defines the manual white balance mode type

【Definition】

 typedef enum rk_aiq_wb_mwb_mode_e {
     RK_AIQ_MWB_MODE_INVAILD              = 0,
     RK_AIQ_MWB_MODE_CCT                  = 1,
     RK_AIQ_MWB_MODE_WBGAIN               = 2,
     RK_AIQ_MWB_MODE_SCENE                = 3,
 } rk_aiq_wb_mwb_mode_t;

【Member】

7.5.3 rk_aiq_wb_gain_t

【Description】 Define the white balance gain parameters

【Definition】

 typedef struct rk_aiq_wb_gain_s {
     float rgain;
     float grgain;
     float gbgain;
     float bgain;
 } rk_aiq_wb_gain_t;

【Member】

7.5.4 rk_aiq_wb_scene_t

【Description】 Define the white balance gain parameters

【Definition】

 typedef enum rk_aiq_wb_scene_e {
     RK_AIQ_WBCT_INCANDESCENT = 0,
     RK_AIQ_WBCT_FLUORESCENT,
     RK_AIQ_WBCT_WARM_FLUORESCENT,
     RK_AIQ_WBCT_DAYLIGHT,
     RK_AIQ_WBCT_CLOUDY_DAYLIGHT,
     RK_AIQ_WBCT_TWILIGHT,
     RK_AIQ_WBCT_SHADE
 } rk_aiq_wb_scene_t;

【Member】

7.5.5 rk_aiq_wb_cct_t

【Description】 Define the white balance gain parameters

【Definition】

 typedef struct rk_aiq_wb_cct_s {
     float CCT;
     float CCRI;
 } rk_aiq_wb_cct_t;

【Member】

7.5.6 rk_aiq_wb_mwb_attrib_t

【Description】 Define manual white balance properties

【Definition】

 typedef struct rk_aiq_wb_mwb_attrib_s {
     rk_aiq_wb_mwb_mode_t mode;
     union MWBPara_u {
         rk_aiq_wb_gain_t gain;
         rk_aiq_wb_scene_t scene;
         rk_aiq_wb_cct_t cct;
     } para;
 } rk_aiq_wb_mwb_attrib_t;

【Member】

7.5.7 rk_aiq_uapiV2_wb_awb_wbGainOffset_t

【Description】 Define the auto white balance gain offset

【Definition】

 typedef struct rk_aiq_uapiV2_wb_awb_wbGainOffset_s{
   rk_aiq_uapi_sync_t sync;
   CalibDbV2_Awb_gain_offset_cfg_t gainOffset;
 }rk_aiq_uapiV2_wb_awb_wbGainOffset_t;

【Member】

7.5.8 CalibDbV2_Awb_gain_offset_cfg_t

【Description】 Define the auto white balance gain offset

【Definition】

 typedef struct CalibDbV2_Awb_gain_offset_cfg_s{
   bool enable;
   float offset[4];
 }CalibDbV2_Awb_gain_offset_cfg_t;

【Member】

7.5.9 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t

【Description】 Define automatic white balance tonal adjustment parameters

【Definition】

 typedef struct rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_s {
   float lumaValue;
   int ct_grid_num;
   int cri_grid_num;
   float ct_in_range[2];//min,max, equal distance sapmle
   float cri_in_range[2];//min,max
   float *ct_lut_out;//size is ct_grid_num*cri_grid_num
   float *cri_lut_out;
 } rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t;
 typedef struct rk_aiq_uapiV2_wb_awb_wbGainAdjust_s {
   rk_aiq_uapi_sync_t sync;
   bool enable;
   rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t *lutAll;
   int lutAll_len;
 } rk_aiq_uapiV2_wb_awb_wbGainAdjust_t;

【Member】

For more instructions, refer to the WBGain color adjustment chapter in the Rockchip_Color_Optimization_Guide documentation

7.5.10 rk_aiq_uapiV2_wbV30_awb_attrib_t

【Description】 Define auto white balance API parameters

【Definition】

 typedef struct rk_aiq_uapiV2_wbV30_awb_attrib_s {
     rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjust;
     CalibDbV2_Awb_gain_offset_cfg_t wbGainOffset;
 } rk_aiq_uapiV2_wbV30_awb_attrib_t;

【Member】

7.5.11 rk_aiq_uapiV2_wbV32_attrib_t

【Description】 Define all parameters supported by the White Balance API.

【Definition】

 typedef struct rk_aiq_uapiV2_wbV30_attrib_s {
     rk_aiq_uapi_sync_t sync;
     bool byPass;
     rk_aiq_wb_op_mode_t mode;
     rk_aiq_wb_mwb_attrib_t stManual;
     rk_aiq_uapiV2_wbV30_awb_attrib_t stAuto;
 } rk_aiq_uapiV2_wbV30_attrib_t;

【Member】

7.6 Module-level API reference

7.6.1 rk_aiq_user_api2_awbV30_SetAllAttrib

【Description】 Set all parameters supported by the White Balance API.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awbV30_SetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wbV30_attrib_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.2 rk_aiq_user_api2_awbV30_GetAllAttrib

【Description】 Get all parameters supported by the White Balance API.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awbV30_GetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wbV30_attrib_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.3 rk_aiq_user_api2_awb_GetCCT

【Description】 Get the white balance color temperature. This function is used both automatically and manually

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_GetCCT(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_cct_t
 *cct);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.4 rk_aiq_user_api2_awb_QueryWBInfo

【Description】 Get the white balance gain factor, color temperature.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_QueryWBInfo(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_querry_info_t *wb_querry_info);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.5 rk_aiq_user_api2_awb_Lock

【Description】 Locks the current white balance parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t* sys_ctx);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.6 rk_aiq_user_api2_awb_Unlock

【Description】 Unlock locked white balance parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t* sys_ctx);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.7 rk_aiq_user_api2_awb_SetWpModeAttrib

【Description】 Set the white balance operating mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_SetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_opMode_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.8 rk_aiq_user_api2_awb_GetWpModeAttrib

【Description】 Gets the white balance operating mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_GetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_opMode_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.9 rk_aiq_user_api2_awb_SetMwbAttrib

【Description】 Set manual white balance parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_mwb_attrib_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.10 rk_aiq_user_api2_awb_GetMwbAttrib

【Description】 Set manual white balance parameters.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_mwb_attrib_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.11 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib

【Description】 Sets the tone adjustment parameters in auto white balance mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.12 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib

【Description】 Gets the tone adjustment parameters in auto white balance mode.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.13 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib

【Description】 Sets the offset of the auto white balance gain

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.6.14 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib

【Description】 Gets the offset of the auto white balance gain

【Grammar】

 XCamReturn
 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t *attr);

【Parameters】

【Return Value】

【Requirements】

Header files: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Library file: librkaiq.so

【Example】

Reference sample_awb_module.cpp

7.7 Module-level API data types

7.7.1 rk_aiq_wb_querry_info_t

【Description】 Define white balance query information

【Definition】

 typedef struct rk_aiq_wb_querry_info_s {
     rk_aiq_wb_gain_t gain;
     rk_aiq_wb_cct_t cctGloabl;
     bool awbConverged;
     uint32_t LVValue;
 } rk_aiq_wb_querry_info_t;

【Member】

7.7.2 rk_aiq_wb_op_mode_t

【Description】 Defines the white balance operating mode

【Definition】

 typedef struct rk_aiq_uapiV2_wb_opMode_s {
   rk_aiq_uapi_sync_t sync;
   rk_aiq_wb_op_mode_t mode;
 } rk_aiq_uapiV2_wb_opMode_t;

【Member】

7.7.3 rk_aiq_wb_mwb_attrib_t

【Description】 Define manual white balance properties

【Definition】

 typedef struct rk_aiq_wb_mwb_attrib_s {
      rk_aiq_uapi_sync_t sync;
     rk_aiq_wb_mwb_mode_t mode;
     union MWBPara_u {
         rk_aiq_wb_gain_t gain;
         rk_aiq_wb_scene_t scene;
         rk_aiq_wb_cct_t cct;
     } para;
 } rk_aiq_wb_mwb_attrib_t;

【Member】

8. AF

8.1 Overview

The function of the AF module refers to the process of adjusting the camera lens so that the image of the subject is clear.

8.2 Description of the feature

The AF module consists of two parts: AF information statistics and AF control algorithm. The figure below shows the block diagram of the AF information statistics module

Among them, ch0/ch1/ch2 corresponds to the S/M/L frame in HDR mode, and debayer is the composite frame in HDR mode.

The output of windowA mainly contains 15*15 V1/V2/H1/H2 FV information, brightness information and highlight count.

The output of windowB mainly contains an FV information, brightness information, and highlight count.

8.3 Development of userAF algorithms

Reference code location: sdk: external/camera_engine_rkaiq/rkisp_demo/demo/af_algo_demo

8.4 Feature-level API reference

8.4.1 rk_aiq_uapi2_setFocusMode

【Description】 ：Configure the focus mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_setFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.2 rk_aiq_uapi2_getFocusMode

【Description】: Gets the current focus mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_getFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t
 *mode);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.3 rk_aiq_uapi2_setFocusWin

【Description】 Set the autofocus window.

【Grammar】

 XCamReturn rk_aiq_uapi2_setFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.4 rk_aiq_uapi2_getFocusWin

【Description】 Set the autofocus window.

【Grammar】

 XCamReturn rk_aiq_uapi2_getFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.5 rk_aiq_uapi2_lockFocus

【Description】 ：Lock autofocus, focus pause action.

【Grammar】

 XCamReturn rk_aiq_uapi2_lockFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.6 rk_aiq_uapi2_unlockFocus

【Description】 Unlock autofocus, focus continues action.

【Grammar】

 XCamReturn rk_aiq_uapi2_unlockFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.7 rk_aiq_uapi2_oneshotFocus

【Description】 Trigger a single focus, after the focus is completed, the focus will not continue.

【Grammar】

 XCamReturn rk_aiq_uapi2_oneshotFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.8 rk_aiq_uapi2_manualTrigerFocus

【Description】 Manually trigger focus, after the focus is completed, continue to monitor whether the picture is blurry, if the picture is blurry, perform focus again.

【Grammar】

 XCamReturn rk_aiq_uapi2_manualTrigerFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.9 rk_aiq_uapi2_trackingFocus

【Description】 Continue to monitor whether the picture is blurry, if the picture is blurry, perform focus again, generally use after rk_aiq_uapi2_oneshotFocus.

【Grammar】

 XCamReturn rk_aiq_uapi2_trackingFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.10 rk_aiq_uapi2_getSearchResult

【Description】 Get the focus result.

【Grammar】

 XCamReturn rk_aiq_uapi2_getSearchResult(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_result_t* result);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.11 rk_aiq_uapi2_getZoomRange

【Description】Gets the zoom range value, which is used to limit the zoom code parameters rk_aiq_uapi_setOpZoomPosition input.

【Grammar】

 XCamReturn rk_aiq_uapi2_getZoomRange(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_zoomrange* range);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.12 rk_aiq_uapi2_setOpZoomPosition

【Description】 Set zoom position, modify zoom position.

【Grammar】

 XCamReturn rk_aiq_uapi2_setOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int pos);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.13 rk_aiq_uapi2_getOpZoomPosition

【Description】 Get the zoom location.

【Grammar】

 XCamReturn rk_aiq_uapi2_getOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int *pos);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.14 rk_aiq_uapi2_endOpZoomChange

【Description】 End the setting of the zoom device position, call after the rk_aiq_uapi_setOpZoomPosition, and perform the focus action after being called.

【Grammar】

 XCamReturn rk_aiq_uapi2_endOpZoomChange(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.15 rk_aiq_uapi2_getFocusRange

【Description】 Gets the focus range value, which is used to limit the focus code parameter rk_aiq_uapi_setFocusPosition input.

【Grammar】

 XCamReturn rk_aiq_uapi2_getFocusRange(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_focusrange* range);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.16 rk_aiq_uapi2_setFocusPosition

【Description】 Set the focus position in manual focus mode.

【Grammar】

 XCamReturn rk_aiq_uapi2_setFocusPosition(const rk_aiq_sys_ctx_t* ctx, unsigned
 short code);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.17 rk_aiq_uapi2_getFocusPosition

【Description】 Gets the current focus position.

【Grammar】

 XCamReturn rk_aiq_uapi2_getFocusPosition(const rk_aiq_sys_ctx_t* ctx, unsigned
 short *code);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.18 rk_aiq_uapi2_startZoomCalib

【Description】 Perform electric motor module correction.

【Grammar】

 XCamReturn rk_aiq_uapi2_startZoomCalib(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.4.19 rk_aiq_uapi2_resetZoom

【Description】 Perform an electric motor module reset.

【Grammar】

 XCamReturn rk_aiq_uapi2_resetZoom(const rk_aiq_sys_ctx_t* ctx);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_imgproc.h

Library file: librkaiq.so

8.5 Functional-level API data types

8.5.1 opMode_t

【Description】 Define the AF information statistics working mode

【Definition】

 typedef enum opMode_e {
     OP_AUTO   = 0,
     OP_MANUAL = 1,
     OP_SEMI_AUTO = 2,
     OP_INVAL
 } opMode_t;

【Member】

8.5.2 rk_aiq_af_zoomrange

【Description】 Define the zoom value range

【Definition】

 typedef struct {
     int min_pos;
     int max_pos;
     float min_fl;
     float max_fl;
 } rk_aiq_af_zoomrange;

【Member】

8.5.3 rk_aiq_af_focusrange

【Description】 Define the focus value range

【Definition】

 typedef struct {
     int min_pos;
     int max_pos;
 } rk_aiq_af_focusrange;

【Member】

8.5.4 rk_aiq_af_result_t

【Description】 Define AF search results

【Definition】

 typedef enum rk_aiq_af_sec_stat_e
 {
     RK_AIQ_AF_SEARCH_INVAL   = 0,
     RK_AIQ_AF_SEARCH_RUNNING = 1,
     RK_AIQ_AF_SEARCH_END     = 2
 } rk_aiq_af_sec_stat_t;
 typedef struct {
     rk_aiq_af_sec_stat_t stat;
     int32_t final_pos;
 } rk_aiq_af_result_t;

【Member】

8.6 Module-level API reference

8.6.1 rk_aiq_user_api2_af_SetAttrib

【Description】 Set the focus properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_af_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_af_attrib_t
 attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_af.h

Library file: librkaiq.so

8.6.2 rk_aiq_user_api2_af_GetAttrib

【Description】 Gets the focus properties.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_af_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_af_attrib_t
 *attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_af.h

Library file: librkaiq.so

8.7 Module-level API data types

8.7.1 RKAIQ_AF_MODE

【Description】 Defines the focus operating mode

【Definition】

 typedef enum _RKAIQ_AF_MODE
 {
     RKAIQ_AF_MODE_NOT_SET = -1,
     RKAIQ_AF_MODE_AUTO,
     RKAIQ_AF_MODE_MACRO,
     RKAIQ_AF_MODE_INFINITY,
     RKAIQ_AF_MODE_FIXED,
     RKAIQ_AF_MODE_EDOF,
     RKAIQ_AF_MODE_CONTINUOUS_VIDEO,
     RKAIQ_AF_MODE_CONTINUOUS_PICTURE,
     RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM,
 } RKAIQ_AF_MODE;

【Member】

8.7.2 RKAIQ_AF_HWVER

【Description】 Defines the focus operating mode

【Definition】

 typedef enum _RKAIQ_AF_HWVER
 {
     RKAIQ_AF_HW_V20 = 0,
     RKAIQ_AF_HW_V30,
     RKAIQ_AF_HW_VMAX
 } RKAIQ_AF_HWVER;

【Member】

8.7.3 rk_aiq_af_algo_meas_v30_t

【Description】 Define the AF information statistics working mode

【Definition】

 typedef struct {
     unsigned char af_en;
     unsigned char rawaf_sel;
     unsigned char gamma_en;
     unsigned char gaus_en;
     unsigned char v1_fir_sel;
     unsigned char hiir_en;
     unsigned char viir_en;
     unsigned char v1_fv_outmode;    // 0 square, 1 absolute
     unsigned char v2_fv_outmode;    // 0 square, 1 absolute
     unsigned char h1_fv_outmode;    // 0 square, 1 absolute
     unsigned char h2_fv_outmode;    // 0 square, 1 absolute
     unsigned char ldg_en;
     unsigned char accu_8bit_mode;   //fix to 1
     unsigned char ae_mode;
     unsigned char y_mode;           //fix to 0
     unsigned char line_en[RKAIQ_RAWAF_LINE_NUM];
     unsigned char line_num[RKAIQ_RAWAF_LINE_NUM];
     unsigned char window_num;
     unsigned short wina_h_offs;
     unsigned short wina_v_offs;
     unsigned short wina_h_size;
     unsigned short wina_v_size;
     unsigned short winb_h_offs;
     unsigned short winb_v_offs;
     unsigned short winb_h_size;
     unsigned short winb_v_size;
     unsigned short gamma_y[RKAIQ_RAWAF_GAMMA_NUM];
     // [old version param]
     unsigned short thres;
     unsigned char shift_sum_a;
     unsigned char shift_sum_b;
     unsigned char shift_y_a;
     unsigned char shift_y_b;

     /**********[Vertical IIR (v1 & v2)]************/
     short v1_iir_coe[9];
     short v1_fir_coe[3];
     short v2_iir_coe[3];
     short v2_fir_coe[3];
     /**********[Horizontal IIR (h1 & h2)]************/
     short h1_iir1_coe[6];
     short h2_iir1_coe[6];
     short h1_iir2_coe[6];
     short h2_iir2_coe[6];
     /**********[Focus value statistic param]**********/
     // level depended gain
     // input8 lumi, output8bit gain
     unsigned char h_ldg_lumth[2];    //luminance thresh
     unsigned char h_ldg_gain[2];     //gain for [minLum,maxLum]
     unsigned short h_ldg_gslp[2];    //[slope_low,-slope_high]
     unsigned char v_ldg_lumth[2];
     unsigned char v_ldg_gain[2];
     unsigned short v_ldg_gslp[2];
     // coring
     unsigned short v_fv_thresh;
     unsigned short h_fv_thresh;
     // left shift, more needed if outmode=square
     unsigned char v1_fv_shift; //only for sel1
     unsigned char v2_fv_shift;
     unsigned char h1_fv_shift;
     unsigned char h2_fv_shift;
     /**********[High light]**********/
     unsigned short highlit_thresh;
 }  rk_aiq_af_algo_meas_v30_t;

【Member】

8.7.4 rk_aiq_af_attrib_t

【Description】 Focus configuration information

【Definition】

 typedef struct rk_aiq_af_attrib_s {
     rk_aiq_uapi_sync_t sync;
     RKAIQ_AF_MODE AfMode;
     RKAIQ_AF_HWVER AfHwVer;
     bool contrast_af;
     bool laser_af;
     bool pdaf;
     int h_offs;
     int v_offs;
     unsigned int h_size;
     unsigned int v_size;
     short fixedModeDefCode;
     short macroModeDefCode;
     short infinityModeDefCode;
     union {
         rk_aiq_af_algo_meas_v20_t manual_meascfg;
         rk_aiq_af_algo_meas_v30_t manual_meascfg_v30;
     };
 } rk_aiq_af_attrib_t;

【Member】

8.8 Additional instructions

8.8.1 VCM motor module driver verification

1. Whether the starting current and termination current of the VCM drive are set correctly,

First of all, it is necessary to obtain relevant information about the starting current and termination current from the module factory.

Next, select a few modules to confirm whether the information is correct, as follows:

In dts, set the start current and termination current to the maximum range that the VCM can support.

Switch the focus mode to manual mode, gradually adjust the VCM position from 64, when the lens starts to move and the telefocus object (more than 10 meters) is clear, record the current position value,

The starting current is (vcm_max_mA - vcm_min_mA) * (64 - curPos) / 64.

Continue to adjust the VCM position, and when the near-focus object (10cm or 20cm) is clear, record the current position value,

The termination current is (vcm_max_mA - vcm_min_mA) * (64 - curPos) / 64.

2. Whether the final residence position is stable when the VCM is moved in different directions.

Switch the focus mode to manual mode, select a position, move from 0 to this position and from 64 to this position, compare whether the two images are consistent in clarity and whether the AF statistics are close.

3. Whether the time required to move the lens is correct.

8.8.2 Electric motor module drive verification

1. Whether multiple single step movements and one multi-step move end up staying in the same position

1. First select a zoom/focus motor position to make the image reach the clearest state, record the current motor position, and grab an image A;

2. Let the zoom or focus motor step back a certain number of steps, and then move the zoom or focus motor in one step until it reaches the recorded zoom/focus motor position, and grab an image B;

3. Let the zoom or focus motor go back a certain number of steps again, move the zoom or focus motor once, reach the recorded zoom/focus motor position, and grab an image C;

4. Compare whether the clarity of image A, image B and image C is consistent, and whether the field of view is consistent;

2. Whether the motor moves randomly and ends up staying in the same position

1. First select a zoom/focus motor position to make the image reach the clearest state, record the current motor position, and grab an image A;

2. Second, let the zoom or focus motor move randomly through the script, move it 400 to 500 times, return to the original zoom/focus motor position, and grab an image B;

3. Compare image A and image B to determine whether the clarity is consistent and whether the field of view is consistent;

3. Whether the final residence position of the motor moving at the same time is the same

1. First select a zoom/focus motor position to make the image reach the clearest state, record the current motor position, and grab an image A;

2. Secondly, let the zoom and focus motor move randomly at the same time through the script, move 400 to 500 times, return to the original zoom/focus motor position, and grab an image B;

3. Compare image A and image B to determine whether the clarity is consistent and whether the field of view is consistent;

9. IMGPROC

9.1 Overview

imgproc refers to the module that affects the effect of the image.

9.2 Merge

9.2.1 Description of the feature

Merge is a module that combines multiple frames of an image into a single frame.

9.2.2 Important concepts

Takes effect in and only in HDR mode.

9.2.3 Functional level API reference

9.2.4 Module-level API reference

9.2.4.1 rk_aiq_user_api2_amerge_SetAttrib

【Description】 Set the merge property.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_amerge_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 amerge_attrib_t attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_amerge.h

Library file: librkaiq.so

9.2.4.2 rk_aiq_user_api2_amerge_GetAttrib

【Description】 Gets the merge property.

【Grammar】

 XCamReturn
 rk_aiq_user_api2_amerge_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 amerge_attrib_t* attr);

【Parameters】

【Return Value】

【Requirements】

Header file: rk_aiq_user_api2_amerge.h

Library file: librkaiq.so

9.2.5 Module-level API data types

9.2.5.1 merge_OpMode_t

【Description】 Define the merge mode of operation

【Definition】

 typedef enum merge_OpModeV21_e {
     MERGE_OPMODE_API_OFF = 0,
     MERGE_OPMODE_MANU    = 1,
 } merge_OpModeV21_t;

【Member】

9.2.5.2 MergeBaseFrame_t

【Description】 Defines datum frame properties when blending

【Definition】

 typedef enum MergeBaseFrame_e {
     BASEFRAME_LONG  = 0,
     BASEFRAME_SHORT = 1,
 } MergeBaseFrame_t;

【Member】

9.2.5.3 MergeCurrCtlData_t

【Description】 Define Merge control parameter attributes.

【Definition】

 typedef struct MergeCurrCtlData_s {
     float Envlv;
     float MoveCoef;
 } MergeCurrCtlData_t;

【Member】

9.2.5.4 mMergeOECurveV21_t

【Description】 Define the Manual Merge Overexposure Curve property

【Definition】

 typedef struct mMergeOECurveV21_s {
     float Smooth;
     float Offset;
 } mMergeOECurveV21_t;

【Member】

9.2.5.5 mMergeMDCurveV21_t

【Description】 Defines motion curve properties in long frame mode

【Definition】

 typedef struct mMergeMDCurveV21_s {
     float LM_smooth;
     float LM_offset;
     float MS_smooth;
     float MS_offset;
 } mMergeMDCurveV21_t;

【Member】

9.2.5.6 mMergeAttrV21_t

【Description】 Define the manual merge attribute in RK3588.

【Definition】

 typedef struct mMergeAttrV21_s {
     mMergeOECurveV21_t OECurve;
     mMergeMDCurveV21_t MDCurve;
 } mMergeAttrV21_t;

【Member】

9.2.5.7 mergeAttrV21_t

【Description】 Configure the merge attribute under the RK356x chip

【Definition】

 typedef struct mergeAttrV21_s {
     merge_OpModeV21_t    opMode;
     mMergeAttrV21_t      stManual;
     MergeCurrCtlData_t   CtlInfo;
 } mergeAttrV21_t;

【Member】

9.2.5.8 mLongFrameModeData_t

【Description】 Defines the control parameter properties in long frame mode

【Definition】

 typedef struct mLongFrameModeData_s {
     mMergeOECurveV21_t OECurve;
     mMergeMDCurveV21_t MDCurve;
 } mLongFrameModeData_t;

【Member】

9.2.5.9 mMergeMDCurveV30Short_t

【Description】 Defines motion curve properties in short frame mode

【Definition】

 typedef struct mMergeMDCurveV30Short_s{
     float Coef;
     float ms_thd0;
     float lm_thd0;
 } mMergeMDCurveV30Short_t;

【Member】

9.2.5.10 mShortFrameModeData_t

【Description】 Define control parameter properties in short frame mode

【Definition】

 typedef struct mShortFrameModeData_s {
     mMergeOECurveV21_t      OECurve;
     mMergeMDCurveV30Short_t MDCurve;
 } mShortFrameModeData_t;

【Member】

9.2.5.11 mMergeAttrV30_t

【Description】 Define the manual merge attribute in RK3588

【Definition】

 typedef struct mMergeAttrV30_s {
     MergeBaseFrame_t      BaseFrm;
     mLongFrameModeData_t  LongFrmModeData;
     mShortFrameModeData_t ShortFrmModeData;
 } mMergeAttrV30_t;

【Member】

9.2.5.12 MergeOECurveV10_t

【Description】 Define the Auto Merge overexposure curve properties

【Definition】

 typedef struct MergeOECurveV10_s {
     float EnvLv[MERGE_ENVLV_STEP_MAX];
     float Smooth[MERGE_ENVLV_STEP_MAX];
     float Offset[MERGE_ENVLV_STEP_MAX];
 } MergeOECurveV10_t;

【Member】

9.2.5.13 MergeMDCurveV10_t

【Description】 Defines motion curve properties in long frame mode

【Definition】

 typedef struct MergeMDCurveV10_s {
     float MoveCoef[MERGE_ENVLV_STEP_MAX];
     float LM_smooth[MERGE_ENVLV_STEP_MAX];
     float LM_offset[MERGE_ENVLV_STEP_MAX];
     float MS_smooth[MERGE_ENVLV_STEP_MAX];
     float MS_offset[MERGE_ENVLV_STEP_MAX];
 } MergeMDCurveV10_t;

【Member】

9.2.5.14 MergeEachChnCurveV12_t

【Description】 Define the properties of the subchannel detection curve in long frame mode

【Definition】

 typedef struct MergeEachChnCurveV12_s {
     float EnvLv[MERGE_ENVLV_STEP_MAX];
     float Smooth[MERGE_ENVLV_STEP_MAX];
     float Offset[MERGE_ENVLV_STEP_MAX];
 } MergeEachChnCurveV12_t;

【Member】

9.2.5.15 LongFrameModeDataV12_t

【Description】 Defines the control parameter properties in long frame mode

【Definition】

 typedef struct LongFrameModeDataV12_s {
     bool                   EnableEachChn;
     MergeOECurveV10_t      OECurve;
     MergeMDCurveV10_t      MDCurve;
     MergeEachChnCurveV12_t EachChnCurve;
     float                  OECurve_damp;
     float                  MDCurveLM_damp;
     float                  MDCurveMS_damp;
 } LongFrameModeDataV12_t;

【Member】

9.2.5.16 MergeMDCurveV11Short_t

【Description】 Defines motion curve properties in short frame mode

【Definition】

 typedef struct MergeMDCurveV11Short_s{
     float Coef;
     float ms_thd0;
     float lm_thd0;
 } MergeMDCurveV11Short_t;

【Member】

9.2.5.17 ShortFrameModeData_t

【Description】 Define control parameter properties in short frame mode

【Definition】

 typedef struct ShortFrameModeData_s {
     MergeOECurveV10_t      OECurve;
     MergeMDCurveV11Short_t MDCurve;
     float                  OECurve_damp;
     float                  MDCurve_damp;
 } ShortFrameModeData_t;

【Member】

9.2.5.18 CalibDbV2_merge_V12_t

【Description】 Define the automerge property

【Definition】

 typedef struct CalibDbV2_merge_V12_s {
     MergeBaseFrame_t       BaseFrm;
     float                  ByPassThr;
     LongFrameModeDataV12_t LongFrmModeData;
     ShortFrameModeData_t   ShortFrmModeData;
 } CalibDbV2_merge_V12_t;

【Member】

9.2.5.19 MergeCurrCtlData_t

【Description】 RK3588 chip under merge attribute configuration

【Definition】

 typedef struct mergeAttrV30_s {
     merge_OpModeV21_t    opMode;
     mMergeAttrV30_t      stManual;
     MergeCurrCtlData_t   CtlInfo;
 } mergeAttrV30_t;

【Member】

9.2.5.20 mergeAttr_t

【Description】 The merge property is configured

【Definition】

 typedef struct mergeAttr_s {
     rk_aiq_uapi_sync_t  sync;
     mergeAttrV21_t      attrV21;
     mergeAttrV30_t      attrV30;
 } mergeAttr_t;

【Member】

9.3 DRC

9.3.1 Description of the feature

DRC (High Dynamic Range Compression), which compresses high-bit images to low-bit images.

9.3.2 Important concepts

DRC can be used in either linear or HDR mode.

9.3.3 Feature-level API reference

9.3.3.1 rk_aiq_uapi2_setDrcGain

【Description】

Quickly set DrcGain curve-related parameters.

【Grammar】