Rockchip Camera Module OTP Calibration: AWB, LSC, PDAF, APIs and Data Formats

This article fully preserves the technical body (PDF pp.9–47) of the 47-page English V1.0.34 source. No corresponding Chinese PDF was supplied. Chinese and Russian fully translate the English source; all three articles use original English-PDF figures, including Chinese labels already present in those originals. Code, parameters, identifiers, example values and code comments retain the source text; prose and captions are localized.

The source chipset scope is reproduced below. It specifies neither a single kernel version nor particular ArmSoM boards. This is an ArmSoM platform reference: verify the actual SoC, module, sensor, VCM/OIS, ISP, SDK/BSP, calibration DLL/API version, drivers and OTP/EEPROM layout. Source module examples are not ArmSoM test results. No hardware validation, calibration, programming or camera operation was performed.

Operational risk and source caveats: OTP/EEPROM programming may be irreversible or overwrite module calibration. Verify the manufacturer workflow and target storage layout first. Several source defaults, function declarations and appendix calls differ. The appendix is a source example, not a guarantee of compilability or production suitability. Formulas, addresses, bit widths and IDs retain the source values; technical constants were not silently corrected.

Source caveats and verification record: EDITORIAL-NOTES. ArmSoM · Rockchip Linux

1 LSC&AWB Calibration process

1.1 Calibration scheme

1. Light source environment and equipment

D50 (5000K±100K) to avoid stray light interference from other environments.

Homogenizer or DNP light box that satisfies the above light source, the homogenizer is shown in the following figure:

Technical figure from the English source, PDF p.9.

2. How to shoot

1. According to the actual situation, you can choose one of the following two methods

1. Use a homogenizer: Place the coated side of the homogenizer facing the lens close to the horizontal, keeping the end face of the module, the homogenizer, and the light source panel parallel.
2. Use DNP light box: Place the module 1-2cm in front of the DNP light source panel, keeping the end face of the module parallel to the light source panel.
3. Disable functions such as mirror/flip
4. Select the exposure value so that the maximum brightness (8bit) of the G channel of the image reaches between 160~180
5. Use that exposure to take a raw image and save it

3. AWB calibration

1. Select the center area of the Raw image (20% of the length and width of each channel) and calculate the mean values of R, Gr, Gb, and B channels

Gr_ave=Gr average of ROI - Black level

Gb_ave=Gb average of ROI - Black level

R_ave = Red average of ROI - Black level

B_ave = Blue average of ROI - Black level

2. Calculate R/Gb and B/Gb and Gr/Gb

R/Gb=R_ave/Gb_ave

B/Gb=B_ave/Gb_ave

Gr/Gb=Gr_ave/Gb_ave

3. Fixed-point R/Gb, B/Gb, and Gr/Gb to 10 bitsR/Gb_hex=R/Gb * 1024

B/Gb_hex=B/Gb * 1024

Gr/Gb_hex=Gr/Gb * 1024

4. LSC calibration

1. Set the target value for the calibration calculation to 70%

2. Calculate the gain of each of the four channels to 10 bits

1.2 Control schemes

1. Before LSC calibration

1. Y shading standard :

ROI = 1/5 Width * 1/5Height

YShading_Corner = Y_Corner/Y_Center

30% < YShading_Corner < 55%

Ydiffer = YShading_Corner_Max - YShading_Corner_Min < 7%

2. Color Shading standard：

Color shading uniformity of a single module (control the difference between each block and the central block of a single module)

ROI frame: 1/5*1/5 Calculate the difference between the 24 blocks and the central block

ROI = 1/5Width * 1/5Height

|(R/G_Corner)/(R/G_Center)-1| < 15%

|(B/G_Corner)/(B/G_Center)-1| < 15%

2. LSC calibration

For the problem of asymmetry of vignetting around the captured RAW data due to module placement problems, the ratio parameter card control calibration result is added lsc_otp_Calibrate interface (default ratio=1.5);

If the optical center shifts due to the assembly of the module itself, the ratio can be increased to increase the pass rate.

3. After LSC calibration

1. Y shading standard :

ROI = 1/5 Width * 1/5Height

YShading_Corner = Y_Corner/Y_Center

Ydiffer = YShading_Corner_Max - YShading_Corner_Min < 5%

2. Color Shading standard：

Color shading uniformity of a single module (control the difference between each block and the central block of a single module)

ROI frame: 1/5*1/5 Calculate the difference between the 24 blocks and the central block

ROI = 1/5Width * 1/5Height

|(R/G_Corner)/(R/G_Center)-1| < 5%

|(B/G_Corner)/(B/G_Center)-1| < 5%

2 PDAF Calibration Process

PDAF calibration is divided into two parts: Gain Map calibration and DCC Map calibration, and the calibration process is as follows:

Technical figure from the English source, PDF p.12.

2.1 Preparation before calibration

1. Module preparation

(1) Lens dirt detection

(2) VCM detection: test linearity, lens position accuracy and stability

(3) AF basic correction:

To determine the relationship between DAC and focus distance—– calibrate the position of the motor of the module lens at the focus Inf and Marco, record the corresponding DAC_inf and Dac_marco values, determine the DCC_LENS_BEGIN and DCC_LENS_END, and the corresponding object distance when the focus is clearest in the center position of the motor is DCC Map calibration distance a.

The center position of the motor DAC = (DAC_INF + DAC_MACRO)/2, and the corresponding calibration distance a can be determined by querying the Lens depth of field table. First, determine the lens shift of INF and MACRO in the lens depth of field table, calculate the middle distance between the two, and find the lens shift closest to the middle distance from the depth of field table, that is, the center position of the motor and the corresponding object distance A. For example, when the object distance is infinite, the corresponding lens shift is 0, and the nearest object distance is selected as 10cm, and the corresponding lens shift is -0.183, then the lens shift in the center position of the motor is -0.0915, which is the closest to -0.091, and the corresponding DCC Map calibrated object distance a is 0.20 meters.

(4) If the module is OIS-enabled, the camera shake correction needs to be completed before calibrating the lsc and pdaf. Move the motor to the reference XY position to verify that the OIS is configured. This step will generate flat field images for LSC and PDAF indexing;

(5) Complete the black level and LSC correction, and if necessary, the field curvature can be corrected

2、Module AE settings

(1) Module AE setting: the digital gain is fixed to 1; Analog gain (traditional PD or 2x1OCL, again set to 1x; Dual-photodiode’s PD and again are set to 2x to prevent pixel blooming)

(2) Exposure time: In order to prevent the charge blooming phenomenon of dual-pd and the overexposure of normal pixels (regular_pixel=dual_pd_l+dual_pd_r), adjust the exposure time to make the brightness of the G channel in the center area 700 (raw10) when displaying the full size; For OCL and metal-shield types, a G- channel brightness of 800 (raw10) is guaranteed in the center area. The sensor recommends that the exposure time be set to an integer multiple of 10ms to avoid power frequency interference.

2.2 Gain Map calibration

1、Light source environment and equipment

D50 (5000K±100K) to avoid stray light interference in other environments；

Homogenizer or DNP light box that meets the above light source, integrating sphere；

2、Shooting method

Technical figure from the English source, PDF p.16.

1. Place the module in front of the uniform surface light source, keep the end face of the module parallel to the light source surface (eg. the integrating sphere used in the experiment, the panel brightness value is adjusted to 6.6), and the homogenizer is placed at the front end of the lens to make the surface light source fill the picture;
2. Sensor’s gain - for metal-shield and 2x1OCL type sensors, set again and dgain to 1x, dual-pd type sensors, again set to 2x, dgain set to 1x, and exposure time set to multiples of 10;
3. Turn off settings such as mirro/flip/OB in the sensor
4. The average brightness value of the TOP 10% G channel in the ROI area of 1/32W*1/32H in the center of the screen is 800LSB (raw10) or 200LSB (raw8) when displayed in full size. The mean value of the dual pd G channel is 700LSB (raw10) or 175LSB (raw8);
5. Turn on the camera to warm up for 3 minutes, move the motor to the center position to shoot 3 RAW images in a row, first check whether the number of dead pixels exceeds the allowable range, if the number of dead pixels exceeds the allowable range, you need to reduce the brightness of the picture and shoot again; If the dead pixel detection passes, the average image data is obtained;

3、Calibration

Calling pdaf_gainmap_calibration (…) The function generates the gainmap data and obtains the size of the gainmap, which is gainmap_width*gainmap_height *2 bytes (including left gainmap and right gainmap).

4、Verification

1. Ensure that the environment in step 2 is the same, take a test image, and input the calibrated gainmap and test image into the function pdaf_gainmap_vertification (…), if the return is 1, the verification is successful, and the calibrated gainmap is available; If the return value is -1, it indicates whether the number of dead pixels exceeds the allowable range, and you need to reduce the brightness of the image and reshoot.

2. Validation criteria

If the difference between the left PD pixel and the right PD pixel corrected by gainmap is less than 5%, the verification is successful.

2.3 DCC Map calibration

DCC (defocus conversion coefficient) represents the relationship between the motor position and the left and right image differences, divides the image into different regions, moves the motor in equal steps, calculates the pd value at different positions, and uses linear regression to obtain the DCC value of different regions —DCCMAP

DCC = Δlensposition[dac]/Δphasedisparity[pixel]

Technical figure from the English source, PDF p.17.

[optional]

For some modules, the PD_OFFSET needs to be calibrated. For example, when the motor is DAC_0, a blurred focus plot is obtained, and the calculated clear focus DAC = DAC_0 + PD * DCC + PD_OFFSET * DCC

1、Light source environment and equipment

D50 (5000K±100K) to avoid stray light interference from other environments.

Homogeneous sheet or DNP light box that meets the above light source, integrating sphere, black and white standard plate;

Standard plate: The standard plate is made of customized translucent film sheet, and the pattern is evenly spaced black and white stripes or diamond-shaped grids.

Technical figure from the English source, PDF p.17.

Technical figure from the English source, PDF p.18.

Technical figure from the English source, PDF p.18.

The calibration distance a is determined in the 2.1.1 AF base correction step

The width of the standard depends on the horizontal FOV of the lens and the calibration distance a, which is recommended

S >= a * tan(FOV * pi/360) * 2/0.9

The calibration distance is determined in the 2.1.1 AF base correction step

The width of the standard depends on the horizontal FOV of the lens and the calibration distance a, which is recommended

λ[mm] = (u[um]/1000) * raw_width/(6 * dccmap_width)

W[mm] = (a[mm] - f[mm])/f[mm] * λ[mm]

For IMX258, the coefficient λ is recommended to be 0.11, and for S5KJN1, the coefficient λ is recommended to be 0.088~0.099.

DCC calibration requires correct customization and placement of the standard board, and the inappropriate size of the stripes, rotation or deformation during placement, and over-dimming or overexposure of the brightness will lead to the failure of DCC calibration, as shown in the figure below for some error cases.

Technical figure from the English source, PDF p.18.

2、How to shoot

1. Place the striped film in front of the integrating sphere, and place the module in front of the standard plate about the middle of the focus, and the distance value is determined by the basic correction in step 2.1.1AF. The end face is kept parallel to the standard plate to avoid rotation, tilt and twisting of the standard plate, and to ensure that the standard plate is full of images when shooting;
2. sensor gain: for metal-shield and 2x1OCL sensors, set again and dgain to 1x, dual-pd sensor, again set to 2x, and dgain set to 1x;
3. Turn off the settings of mirro/flip/OB/dead pixel removal in the sensor;
4. Exposure: Ensure that the average value of the white block g channel in the ROI area of 1/32w*1/32h in the center of the standard plate screen is 800LSB (raw10) and 200LSB (raw8), and the average value of the dual pd G channel is 700LSB (raw10) or 175LSB (raw8), so as to avoid insufficient brightness or overexposure affecting the DCC calibration accuracy; For metal-shield sensors, ensure that the non-shielded pixels are not overexposed.
5. Move the motor from DCC_LENS_BEGIN to DCC_LENS_END at DCC_LENS_INTERVAL sampling intervals, and take three RAW images after the motor stabilizes each time to obtain the average image data of each position (eg. During the experiment, the code was moved from 0 to 64 at 8 intervals, and a total of 9 positions were taken, and 27 images were taken

3、Demarcate

Enter the gainmap, motor position parameters, and average image data for each position calibrated in Section 2.1 into the function pdaf_dccmap_calibration (…) to obtain the dccmap data and obtain the size of the dccmap,

the size is dccmap _width*dccmap _height *2 bytes (if the calibration PD_OFFSET is selected, the value size is 2bytes at the same time DCC_RSQ_THRESHOLD); If the number of blocks that do not meet the linearity threshold is greater than a certain number, the calibration fails, and you need to check whether the input data is incorrect, adjust the calibration environment and shoot again.

4、Verify

The purpose of this step is to verify that the current calibrated dccmap is correct The verification process is shown in the following figure:

Technical figure from the English source, PDF p.19.

1. The lighting environment of the verification data shooting is the same as that of the DCCmap calibration environment, and the lens surface is parallel to the standard plate to ensure that the image is filled with the standard plate pattern during shooting.

2. Turn on the camera to warm up for 3 minutes, and adjust the motor to a image blur position DAC0，

DAC0 ∈ (DACinf + 0.2 * abs(DACinf - DACmacro), DACinf + 0.8 * abs(DACinf - DACmacro)]

After the motor is stabilized, three Raw images are captured, the average image data is obtained, and the current position information of the motor DAC0, the average image data, and the calibrated gainmap and dccmap are input into the pdaf_dccmap_vertification() function, and the ideal focusing position DAC1 of the image at the focus blur is calculated；

3. Then move the motor to DAC1, and capture five images in tolerance_factor*abs(DACinf-DACmacro)+Δ (e.g.Δ=2) before and after DAC1, tolerance_factor the tolerance range during verification, and the error range is different for different types of sensors (e.g.5%, 10%, 20%).

Move the motor from position 1 to position 5 during verification, and the five positions are (e.g.tolerance_factor=10%, Δ=2)

4.

5. Pass five graphs into the function pdaf_calc_sharpness (…) Calculate the sharpness of the image center area DCC_PERCENT_ROI_W* DCC_PERCENT_ROI_H (e.g.30%*30%), and judge whether there is a peak, and if so, the verification is successful; If the verification fails, zoom in on the range of tolerance_factor and Δ (e.g. Δ from 2 to 5), re-acquire 5 images, and repeat step 4. It is best to choose a channel with fewer PD pixels to calculate the definition.

Technical figure from the English source, PDF p.20.

3 Calibration scheme

Calibrated modules include AWB (Auto White Balance), LSC (Lens Shading Correction), and PDAF (Phase Detection Auto-focus).

3.1 AWB calibration

【Function Description】

This function is used to calculate the R/G,B/G Gr/Gb of ROI in a raw image.

【Function Prototype】

bool awb_otp_Calibrate(uint16_t* RawAddr, int width, int height, int roiw,
                       int roih, int bits, int bayer, int blc_r, int blc_gr,
                       int blc_gb, int blc_b, uint16_t* R, uint16_t* Gr,
                       uint16_t*Gb, uint16_t* B, uint16_t* R_G, uint16_t* B_G,
                       uint16_t* Gr_Gb)

【Enter information】

【Output Information】

【Return value】

=0：The parameter is incorrect

=1：The calibration was successful

3.2 LSC calibration

3.2.1 LSC calibration

【Feature description】

This function is used to calculate the gain of each channel of the raw image.

【Function prototypes】

bool lsc_otp_Calibrate(int vig,uint16_t* RawAddr, int width, int height,
                       int bits, int bayer, int blc_r, int blc_gr,
                       int blc_gb, int blc_b, float ratio, uint16_t* lsc_otp)

【Enter your information】

【Output Information】

【Return Value】

=0：The LSC calibration data is abnormal and the vignetting is abnormal

=1：calibration succeeded

3.2.2 LSC Validation

【Feature description】

This function is used to verify the results of the LSC calibration.

【Function prototypes】

bool lsc_otp_verify(uint16_t *RawAddr, int width, int height, int bits,
                    int bayer, int blc_r, int blc_gr, int blc_gb,
                    int blc_b, uint16_t *lsc_otp, int Ydiffer_down,
                    int Ydiffer_up, int ColorShading_down,
                    int ColorShading_up, float *fYdiffer,
                    float *fRGCorner,float *fBGCorner)

【Enter your information】

【Output information】

【Return value】

=0：If the calibrated control indicators are not met, the verification fails

=1：Verification successful

3.3 PDAF calibration

3.3.1 Get sensor config

【Feature description】

Configure the sensor.ini file and get information about the PD sensor from the sensor.ini file.

【Configure the content】

[sensor config]

Dual type

[sensor config]

[Gainmap_Calib]

[DCCmap_Calib]

[optional params]

【Example】

Take the IMX258 pd pixel distribution as an example, as shown in the following figure:

Technical figure from the English source, PDF p.30.

According to the information on the figure, the contents of the sensor.ini file are as follows:

[sensor config]
RAW_WIDTH =4208
RAW_HEIGHT =3120
RAW_BITS =12
RAW_BLACK_LEVEL =64
RAW_BAYER_PATTERN =0
SENSOR_TYPE=0
PD_DUAL_MODE=0
PD_BINNING_TYPE=0
PD_OFFSET_X =24
PD_OFFSET_Y =24
PD_PITCH_X =32
PD_PITCH_Y =32
PD_DENSITY_X =16
PD_DENSITY_Y =16
PD_BLOCK_NUM_X =130
PD_BLOCK_NUM_Y =96
CALB_S_LEVEL=1000
CALB_S_CNT=10
PD_POS_L=
[26 29]
[42 29]
[33 48]
[49 48]; #end with a ";"
PD_POS_R=
[25 32]
[41 32]
[34 45]
[50 45]; #end with a ";"
[Gainmap_Calib]
GAINMAP_BLKSZ_W=16
GAINMAP_BLKSZ_H=16
GAIN_CALIB_INPUT_MAX=920
GAIN_CALIB_INPUT_MIN=800
GAIN_VERIFY_DIFF_MAX=5
CROSS_VER=1
[DCCmap_Calib]
DCCMAP_BLKSZ_W=32
DCCMAP_BLKSZ_H=32
DCC_CALIBRATE_MODE=1
DCC_LENS_BEGIN=0
DCC_LENS_END=64
DCC_LENS_INTERVAL=8
DCC_RSQ_THRESHOLD=0.985
DCC_BORDER_RSQ_THRESHOLD=0.97
DCC_BAD_RSQ_NUM_RATIO=0.05
DCC_CALIB_INPUT_MAX=640
DCC_CALIB_INPUT_MIN=340
DCC_VERIFY_CAF_DIFF_MAX=10
DCC_VERIFY_CAF_DIFF_DET=2
CALIB_TARGET_PEAK_OFFSET_LOG=0
CALIB_TARGET_PEAK_OFFSET=0
DCC_PERCENT_ROI_W=0.4
DCC_PERCENT_ROI_H=0.4
DCC_SHARPNESS_MODE=1
DCC_SHARPNESS_CHL=1
[optional params]
QUALITY_VERIFY_ENABLE=1
QUALTI_LRDiff_L_MIN=0.4
QUALTI_LRDiff_L_MAX=2.5
QUALTI_LRDiff_C_MIN=0.55
QUALTI_LRDiff_C_MAX=1.8
QUALTI_LRDiff_R_MIN=0.4
QUALTI_LRDiff_R_MAX=2.5
QUALITY_SENSITIVITY_MIN=0.45

【Function prototypes】

bool pdaf_initial(char* filename, sensor_cfg* psensor_cfg)

【Iutput information】

【Output information】

【Return value】

=0：Failed to get sensor.ini

=1：Get sensor.ini successfully

3.3.2 Gain Map calibration

【Feature description】

This function is used for the indexing of PDAF gain maps.

【Function prototypes】

bool pdaf_gainmap_calibration(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                              uint16_t *gainmap_lut,int* gainmap_width,
                              int* gainmap_height)

【Iutput information】

【Output information】

【Return value】

=0：The parameter is incorrect

=1：Calibration successful

3.3.3 Gain Map Validation

【Feature description】

This function is used to verify whether the calibrated gain map meets the requirements.

【Function prototypes】

bool pdaf_gainmap_vertification(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                                uint16_t *gainmap_lut)

【Iutput information】

【Return value】

=0：The validation failed, and the gainmap used for validation did not meet the requirements.

=1：Verification successful

3.3.4 DCC Map calibration

【Feature description】

This function is used for the calibration of PDAF DCC MAP.

【Function prototypes】

bool pdaf_dccmap_calibration(uint16_t *RawAddrAll , sensor_cfg* psensor_cfg,
                             uint16_t *gainmap_lut, uint16_t *dccmap_lut,
                             int* dccmap_width,int* dccmap_height,
                             uint8_t* dccSign,wchar_t*pd_offset)

【Iutput information】

【Output information】

【Return value】

=0：Calibration failed

=1：Calibration successful

3.3.5 DCC Map Verification

Used to verify whether the calibrated dcc map meets the requirements, including two function interfaces pdaf_dccmap_vertification() and pdaf_calc_sharpness().

【Function description】

Use the calibrated dcc map to obtain the ideal focus clear position DAC1 of the blurred image;

【function prototype】

uint16_t pdaf_dccmap_vertification(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                                   int cur_pos_id, uint16_t *gainmap_lut,
                                   uint16_t *dccmap_lut, uint8_t dccSign, wchar_t
*pd_offset)

【Iutput information】

【Return value】

Motor position DAC1 when blurred image is ideally in focus.

【Function description】

Calculate the sharpness of the image center area within the DCC_VERIFY_CAF_DIFF_MAX*abs (DACinf- DACmacro)+DCC_VERIFY_CAF_DIFF_DET before and after DAC1 to determine whether there is a peak.

【function prototype】

bool pdaf_calc_sharpness(uint16_t *RawAddrAll, int img_num, sensor_cfg*
psensor_cfg)

【Iutput information】

【Return value】

=0：No sharpness peak found, verification failed

=1：Verification successful

4 Appendix

4.1 OTP application sample code

#include <iostream>
#include "RKOTPDLL.h"
#include <stdlib.h>
int main()
{
    int ret = 0;
    #LSC AWB Otp Calibration
    ret =lsc_awbtest();
    #Pdaf Otp Calibration
    uint16_t gainmap[30*30 * 2];
    uint16_t dccmap[20 * 20 * 2];
    uint16_t code = 0;
    int gainmap_width = 0;
    int gainmap_height = 0;
    int dccmap_width = 0;
    int dccmap_height = 0;
    uint8_t dcc_Sign = 0;
    wchar_t pd_offset=0xffff;
    int curpos = 864;
    sensor_cfg sensor_param;
    if (pdaf_initial("D:\\testdll\\testdll\\sensor_ov16A10.ini", &sensor_param))
    {
        if (gainmaptest(&sensor_param, gainmap,&gainmap_width,&gainmap_height))
        {
        if (dccmaptest(&sensor_param, gainmap, dccmap, curpos, &code,
&dccmap_width, &dccmap_height, &dcc_Sign,&pd_offset))
            {
                ret = dcc_calc_sharpness(&sensor_param);
            }
        }
    }
}
bool lsc_awbtest()
{
    int vig=70;
    int height = 1944;
    int width = 2592;
    int bits =10;#10bit
    int bayer =0;#BGGR
    int roiw =5;#1/5 width
    int roih =5;#1/5 height
    int blc[4]={ 64, 64, 64, 64};
    uint16_t lsctable[17*17*4];
    uint16_t awb[3];
    uint16_t Rave =0;
    uint16_t Grave =0;
    uint16_t Gbave =0;
    uint16_t Bave =0;
    int Ydiffer_down =0;#%
    int Ydiffer_up =5;#%
    int ColorShading_down =0;#%
    int ColorShading_up =5;#%
    float Ydiffer = 0;
    float RGconer[25];
    float BGconer[25];
    bool ret =0;
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    fp = fopen("input.raw", "rb");
    if (fp == NULL)
    {
        return false;
    }
    fread(Rawdata, 1, height * width * 2, fp);
    fclose(fp);
    ret =lsc_otp_Calibrate(vig,Rawdata, width, height, bits, bayer, blc[0],
blc[1],blc[2], blc[3],lsctable);
    ret = awb_otp_Calibrate(Rawdata, width, height,roiw,roih, bits, bayer,
blc[0], blc[1],blc[2], blc[3],&Rave,&Grave,&Gbave,&Bave, &awb[0], &awb[1],
&awb[2]);
    ret = lsc_otp_verify(Rawdata, width, height, bits, bayer, blc[0], blc[1],
blc[2], blc[3], lsctable, Ydiffer_down, Ydiffer_up, ColorShading_down,
ColorShading_up, &Ydiffer, RGconer, BGconer);
    if(!ret)
    {
        return false; #The calibrated data does not meet the control standards and the verification fails.
    }
    if(Rawdata!=NULL)
    {
        free (Rawdata);
        Rawdata =NULL;
    }
    return ret;
}
int gainmaptest(sensor_cfg* psensor_cfg, uint16_t *gainmap_lut,int *
gainmap_width, int *gainmap_height)
{
    int ret = 0;
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    uint16_t maxval = (1 << psensor_cfg->bits) - 1;
    int gainmapfilenum = 3;
    int over_exp_cnt = 0;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type+1)*psensor_cfg->pd_height;
    }
    uint16_t *ave_pixelbuf = NULL;
    ave_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *sum_pixelbuf = NULL;
    sum_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(sum_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *pixelbuf = NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "gainRAW";
    char endname[5] = ".raw";
    for (int i = 0; i < gainmapfilenum; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        for (int j = 0; j < height; j++)
        {
            for (int i = 0; i < width; i++)
            {
                uint32_t tempbuf = *(pixelbuf + j*width + i);
                *(sum_pixelbuf + j*width + i) = tempbuf + *(sum_pixelbuf +
j*width + i);
                if (tempbuf >= maxval)
                    over_exp_cnt++;
            }
        }
    }
    for (int j = 0; j < height; j++)
    {
        for (int i = 0; i < width; i++)
        {
            *(ave_pixelbuf + j*width + i) = *(sum_pixelbuf + j*width + i) /
gainmapfilenum;
        }
    }
    ret = pdaf_gainmap_calibration(ave_pixelbuf, psensor_cfg, gainmap_lut,
gainmap_width,gainmap_height);
    ret = pdaf_gainmap_vertification(ave_pixelbuf, psensor_cfg, gainmap_lut);
    if(ret == -1)
        printf("gainmap image OVER exposure!!!");
    if (ave_pixelbuf!=NULL)
    {
        free(ave_pixelbuf);
        ave_pixelbuf = NULL;
    }
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (sum_pixelbuf != NULL)
    {
        free(sum_pixelbuf);
        sum_pixelbuf = NULL;
    }
    return ret;
}
bool dccmaptest(sensor_cfg* psensor_cfg, uint16_t *gainmap_lut, uint16_t
*dccmap_lut, int curpos , uint16_t *code, int *dccmap_width, int *dccmap_height,
uint8_t *dcc_Sign,wchar_t *pdaf_offset)
{
    int ret = 0;
    int lens_begin = 0;
    int lens_end = 64;
    int lens_interval = 8;
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    int lensnum = (lens_end - lens_begin) / lens_interval + 1;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type +
1)*psensor_cfg->pd_height;
    }
    uint16_t *ave_pixelbuf = NULL;
    ave_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2 * lensnum);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height* lensnum);
    uint16_t *pixelbuf= NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "dccRAW";
    char endname[5] = ".raw";
    for (int a = 0;a <lensnum;a++)
    {
        char temp[20];
        char id[5] ;
        int id1 = a + 1;
        strcpy(temp,prename);
        _itoa_s(id1, id, 10);
        strcat(temp, id);
        for (int b = 0; b < 3;b++)
        {
            char name[20];
            strcpy(name, temp);
            int id2 = b + 1;
            _itoa_s(id2, id, 10);
            strcat(name, id);
            strcat(name, endname);
            fp = fopen(name, "rb");
            if (fp == NULL)
            {
                return false;
            }
            fread(pixelbuf, 1, height * width * 2, fp);
            fclose(fp);
            for (int j = 0; j < height; j++)
            {
                for (int i = 0; i < width; i++)
                {
                    uint16_t tempbuf = *(ave_pixelbuf + j*width + i);
                    *(ave_pixelbuf + j*width + i) = tempbuf + *(pixelbuf +
j*width + i) / 3;
                }
            }
        }
        memcpy(Rawdata + a*height * width, ave_pixelbuf, sizeof(uint16_t)*height
* width);
        memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    }
    ret = pdaf_dccmap_calibration(Rawdata, psensor_cfg, gainmap_lut, dccmap_lut,
dccmap_width, dccmap_height, dcc_Sign,pd_offset);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    char prename1[20] = "image";
    for (int i = 0; i < 3; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename1);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        for (int j = 0; j < height; j++)
        {
            for (int i = 0; i < width; i++)
            {
                uint16_t tempbuf = *(ave_pixelbuf + j*width + i);
                *(ave_pixelbuf + j*width + i) = tempbuf + *(pixelbuf + j*width +
i) / 3;
            }
        }
    }
        *code = pdaf_dccmap_vertification(ave_pixelbuf, psensor_cfg, curpos,
gainmap_lut, dccmap_lut, *dcc_Sign,pd_offset);
    if (ave_pixelbuf != NULL)
    {
        free(ave_pixelbuf);
        ave_pixelbuf = NULL;
    }
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (Rawdata != NULL)
    {
        free(Rawdata);
        Rawdata = NULL;
    }
    return ret;
}
bool dcc_calc_sharpness(sensor_cfg* psensor_cfg)
{
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    int imgnum = 5;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type +
1)*psensor_cfg->pd_height;
    }
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2 * imgnum);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height* imgnum);
    uint16_t *pixelbuf = NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "calimage";
    char endname[5] = ".raw";
    for (int i = 0; i < imgnum; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        memcpy(Rawdata + i*height * width, pixelbuf, sizeof(uint16_t)*height *
width);
    }
    bool ret=pdaf_calc_sharpness(Rawdata, imgnum, psensor_cfg);
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (Rawdata != NULL)
    {
        free(Rawdata);
        Rawdata = NULL;
    }
    return ret;
}

4.2 Burning packaged data format

As shown in the following table, users can burn certain blocks specified according to their needs (note that the ID of the block is not allowed to be changed), and the 0xff that needs to be burned after the required blocks are burned is completed:

The specific content of the block is as follows. Multi-byte data is unified in big-endian mode. The high byte is stored in the low address and the low byte is stored in the high address: