#include "rk_aiq_anr_algo_uvnr.h"
|
|
RKAIQ_BEGIN_DECLARE
|
|
ANRresult_t uvnr_get_mode_cell_idx_by_name(CalibDb_UVNR_2_t *pCalibdb, char *name, int *mode_idx)
|
{
|
int i = 0;
|
ANRresult_t res = ANR_RET_SUCCESS;
|
|
if(pCalibdb == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(name == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(mode_idx == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pCalibdb->mode_num < 1){
|
LOGE_ANR("%s(%d): uvnr mode cell num is zero\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
for(i=0; i<pCalibdb->mode_num; i++){
|
if(strncmp(name, pCalibdb->mode_cell[i].name, sizeof(pCalibdb->mode_cell[i].name)) == 0){
|
break;
|
}
|
}
|
|
if(i < pCalibdb->mode_num){
|
*mode_idx = i;
|
res = ANR_RET_SUCCESS;
|
}else{
|
*mode_idx = 0;
|
res = ANR_RET_FAILURE;
|
}
|
|
LOGD_ANR("%s:%d mode_name:%s mode_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *mode_idx, i);
|
return res;
|
|
}
|
|
ANRresult_t uvnr_get_setting_idx_by_name(CalibDb_UVNR_2_t *pCalibdb, char *name, int mode_idx, int *setting_idx)
|
{
|
int i = 0;
|
ANRresult_t res = ANR_RET_SUCCESS;
|
|
if(pCalibdb == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(name == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(setting_idx == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
for(i=0; i<CALIBDB_NR_SHARP_SETTING_LEVEL; i++){
|
if(strncmp(name, pCalibdb->mode_cell[mode_idx].setting[i].snr_mode, sizeof(pCalibdb->mode_cell[mode_idx].setting[i].snr_mode)) == 0){
|
break;
|
}
|
}
|
|
if(i<CALIBDB_NR_SHARP_SETTING_LEVEL){
|
*setting_idx = i;
|
res = ANR_RET_SUCCESS;
|
}else{
|
*setting_idx = 0;
|
res = ANR_RET_FAILURE;
|
}
|
|
LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__,name,* setting_idx, i);
|
return res;
|
|
}
|
|
ANRresult_t uvnr_config_setting_param(RKAnr_Uvnr_Params_t *pParams, CalibDb_UVNR_2_t *pCalibdb, char* param_mode, char * snr_name)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
int mode_idx = 0;
|
int setting_idx = 0;
|
|
if(pParams == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pCalibdb == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
res = uvnr_get_mode_cell_idx_by_name(pCalibdb, param_mode, &mode_idx);
|
if(res != ANR_RET_SUCCESS){
|
LOGW_ANR("%s(%d): error!!! can't find mode cell in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
|
}
|
|
res = uvnr_get_setting_idx_by_name(pCalibdb, snr_name, mode_idx, &setting_idx);
|
if(res != ANR_RET_SUCCESS){
|
LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
|
}
|
|
res = init_uvnr_params(pParams, pCalibdb, mode_idx, setting_idx);
|
|
return res;
|
|
}
|
|
ANRresult_t init_uvnr_params(RKAnr_Uvnr_Params_t *pParams, CalibDb_UVNR_2_t *pCalibdb, int mode_idx, int setting_idx)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
int i = 0;
|
int j = 0;
|
|
if(pParams == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pCalibdb == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
CalibDb_UVNR_Params_t *pSetting = &pCalibdb->mode_cell[mode_idx].setting[setting_idx];
|
for(i = 0; i < MAX_ISO_STEP; i++) {
|
#ifndef RK_SIMULATOR_HW
|
pParams->iso[i] = pSetting->ISO[i];
|
#endif
|
pParams->ratio[i] = pSetting->step0_uvgrad_ratio[i];
|
pParams->offset[i] = pSetting->step0_uvgrad_offset[i];
|
|
pParams->wStep1[i] = pSetting->step1_downSample_w[i];
|
pParams->hStep1[i] = pSetting->step1_downSample_h[i];
|
pParams->meanSize1[i] = pSetting->step1_downSample_meansize[i];
|
|
pParams->medSize1[i] = pSetting->step1_median_size[i];
|
pParams->medRatio1[i] = pSetting->step1_median_ratio[i];
|
pParams->isMedIIR1[i] = pSetting->step1_median_IIR[i];
|
|
pParams->bfSize1[i] = pSetting->step1_bf_size[i];
|
pParams->sigmaR1[i] = pSetting->step1_bf_sigmaR[i];
|
pParams->sigmaD1[i] = pSetting->step1_bf_sigmaD[i];
|
pParams->uvgain1[i] = pSetting->step1_bf_uvgain[i];
|
pParams->bfRatio1[i] = pSetting->step1_bf_ratio[i];
|
pParams->isRowIIR1[i] = pSetting->step1_bf_isRowIIR[i];
|
pParams->isYcopy1[i] = pSetting->step1_bf_isYcopy[i];
|
|
pParams->wStep2[i] = pSetting->step2_downSample_w[i];
|
pParams->hStep2[i] = pSetting->step2_downSample_h[i];
|
pParams->meanSize2[i] = pSetting->step2_downSample_meansize[i];
|
|
pParams->medSize2[i] = pSetting->step2_median_size[i];
|
pParams->medRatio2[i] = pSetting->step2_median_ratio[i];
|
pParams->isMedIIR2[i] = pSetting->step2_median_IIR[i];
|
|
pParams->bfSize3[i] = pSetting->step2_bf_size[i];
|
pParams->sigmaR2[i] = pSetting->step2_bf_sigmaR[i];
|
pParams->sigmaD2[i] = pSetting->step2_bf_sigmaD[i];
|
pParams->uvgain2[i] = pSetting->step2_bf_uvgain[i];
|
pParams->bfRatio2[i] = pSetting->step2_bf_ratio[i];
|
pParams->isRowIIR2[i] = pSetting->step2_bf_isRowIIR[i];
|
pParams->isYcopy2[i] = pSetting->step2_bf_isYcopy[i];
|
|
pParams->bfSize3[i] = pSetting->step3_bf_size[i];
|
pParams->sigmaR3[i] = pSetting->step3_bf_sigmaR[i];
|
pParams->sigmaD3[i] = pSetting->step3_bf_sigmaD[i];
|
pParams->uvgain3[i] = pSetting->step3_bf_uvgain[i];
|
pParams->bfRatio3[i] = pSetting->step3_bf_ratio[i];
|
pParams->isRowIIR3[i] = pSetting->step3_bf_isRowIIR[i];
|
pParams->isYcopy3[i] = pSetting->step3_bf_isYcopy[i];
|
|
}
|
|
for(i=0; i<4; i++){
|
pParams->nonMed1[i] = pSetting->step1_nonMed1[i];
|
pParams->nonBf1[i] = pSetting->step1_nonBf1[i];
|
pParams->block2_ext[i] = pSetting->step2_nonExt_block[i];
|
pParams->nonMed2[i] = pSetting->step2_nonMed[i];
|
pParams->nonBf2[i] = pSetting->step2_nonBf[i];
|
pParams->nonBf3[i] = pSetting->step3_nonBf3[i];
|
}
|
|
for(i=0; i<3; i++){
|
pParams->kernel_3x3_table[i] = pSetting->kernel_3x3[i];
|
}
|
|
for(i=0; i<5; i++){
|
pParams->kernel_5x5_talbe[i] = pSetting->kernel_5x5[i];
|
}
|
|
for(i=0; i<8; i++){
|
pParams->kernel_9x9_table[i] = pSetting->kernel_9x9[i];
|
}
|
|
pParams->kernel_9x9_num = pSetting->kernel_9x9_num;
|
|
for(i=0; i<9; i++){
|
pParams->sigmaAdj_x[i] = pSetting->sigma_adj_luma[i];
|
pParams->sigamAdj_y[i] = pSetting->sigma_adj_ratio[i];
|
|
pParams->threAdj_x[i] = pSetting->threshold_adj_luma[i];
|
pParams->threAjd_y[i] = pSetting->threshold_adj_thre[i];
|
}
|
|
return ANR_RET_SUCCESS;
|
|
}
|
|
ANRresult_t uvnr_get_setting_idx_by_name_json(CalibDbV2_UVNR_t *pCalibdb, char *name, int *tuning_idx)
|
{
|
int i = 0;
|
ANRresult_t res = ANR_RET_SUCCESS;
|
|
if(pCalibdb == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(name == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(tuning_idx == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
for(i=0; i<pCalibdb->TuningPara.Setting_len; i++){
|
if(strncmp(name, pCalibdb->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0){
|
break;
|
}
|
}
|
|
if(i<pCalibdb->TuningPara.Setting_len){
|
*tuning_idx = i;
|
res = ANR_RET_SUCCESS;
|
}else{
|
*tuning_idx = 0;
|
res = ANR_RET_FAILURE;
|
}
|
|
LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__,name,*tuning_idx, i);
|
return res;
|
|
}
|
|
|
ANRresult_t init_uvnr_params_json(RKAnr_Uvnr_Params_t *pParams, CalibDbV2_UVNR_t *pCalibdb, int setting_idx)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
int i = 0;
|
int j = 0;
|
float luma[9] = {0.0000, 32.0000, 64.0000, 96.0000, 128.0000, 160.0000, 192.0000, 224.0000, 256.0000 };
|
|
if(pParams == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pCalibdb == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
CalibDbV2_UVNR_TuningPara_Setting_t *pSetting = &pCalibdb->TuningPara.Setting[setting_idx];
|
CalibDbV2_UVNR_TuningPara_Setting_ISO_t *pTuning_ISO = NULL;
|
for(i = 0; i < pSetting->Tuning_ISO_len; i++) {
|
pTuning_ISO = &pSetting->Tuning_ISO[i];
|
#ifndef RK_SIMULATOR_HW
|
pParams->iso[i] = pTuning_ISO->iso;
|
#endif
|
pParams->ratio[i] = pTuning_ISO->step0_uvgrad_ratio;
|
pParams->offset[i] = pTuning_ISO->step0_uvgrad_offset;
|
|
pParams->wStep1[i] = 4;
|
pParams->hStep1[i] = 4;
|
pParams->meanSize1[i] = 4;
|
|
pParams->medSize1[i] = 3;
|
pParams->medRatio1[i] = pTuning_ISO->step1_median_ratio;
|
pParams->isMedIIR1[i] = 0;
|
|
pParams->bfSize1[i] = 5;
|
pParams->sigmaR1[i] = pTuning_ISO->step1_bf_sigmaR;
|
pParams->sigmaD1[i] = 16;
|
pParams->uvgain1[i] = pTuning_ISO->step1_bf_uvgain;
|
pParams->bfRatio1[i] = pTuning_ISO->step1_bf_ratio;
|
pParams->isRowIIR1[i] = 0;
|
pParams->isYcopy1[i] = 1;
|
|
pParams->wStep2[i] = 32;
|
pParams->hStep2[i] = 32;
|
pParams->meanSize2[i] =8;
|
|
pParams->medSize2[i] = 3;
|
pParams->medRatio2[i] = pTuning_ISO->step2_median_ratio;
|
pParams->isMedIIR2[i] = 0;
|
|
pParams->bfSize3[i] = 5;
|
pParams->sigmaR2[i] = pTuning_ISO->step2_bf_sigmaR;
|
pParams->sigmaD2[i] = 128;
|
pParams->uvgain2[i] = pTuning_ISO->step2_bf_uvgain;
|
pParams->bfRatio2[i] = pTuning_ISO->step2_bf_ratio;
|
pParams->isRowIIR2[i] = 0;
|
pParams->isYcopy2[i] = 1;
|
|
pParams->bfSize3[i] = 3;
|
pParams->sigmaR3[i] = pTuning_ISO->step3_bf_sigmaR;
|
pParams->sigmaD3[i] = 8;
|
pParams->uvgain3[i] = pTuning_ISO->step3_bf_uvgain;
|
pParams->bfRatio3[i] = pTuning_ISO->step3_bf_ratio;
|
pParams->isRowIIR3[i] = 0;
|
pParams->isYcopy3[i] = 1;
|
|
}
|
|
for(i=0; i<4; i++){
|
pParams->nonMed1[i] = 3;
|
pParams->nonBf1[i] = 31;
|
pParams->block2_ext[i] = 7;
|
pParams->nonMed2[i] = 1;
|
pParams->nonBf2[i] = 3;
|
pParams->nonBf3[i] = 32;
|
}
|
|
for(i=0; i<3; i++){
|
pParams->kernel_3x3_table[i] = pCalibdb->TuningPara.Kernel_Coeff.kernel_3x3[i];
|
}
|
|
for(i=0; i<5; i++){
|
pParams->kernel_5x5_talbe[i] = pCalibdb->TuningPara.Kernel_Coeff.kernel_5x5[i];
|
}
|
|
for(i=0; i<8; i++){
|
pParams->kernel_9x9_table[i] = pCalibdb->TuningPara.Kernel_Coeff.kernel_9x9[i];
|
}
|
|
pParams->kernel_9x9_num = pCalibdb->TuningPara.Kernel_Coeff.kernel_9x9_num;
|
|
for(i=0; i<9; i++){
|
pParams->sigmaAdj_x[i] = luma[i];
|
pParams->sigamAdj_y[i] = 1;
|
|
pParams->threAdj_x[i] = luma[i];
|
pParams->threAjd_y[i] = 10;
|
}
|
|
uvnr_algo_param_printf(pParams);
|
return ANR_RET_SUCCESS;
|
|
}
|
|
ANRresult_t uvnr_algo_param_printf(RKAnr_Uvnr_Params_t *pParams)
|
{
|
int i,j;
|
|
if(pParams != NULL){
|
for(i=0; i<MAX_ISO_STEP; i++){
|
#ifndef RK_SIMULATOR_HW
|
LOGD_ANR("uvnr iso:%f\n",
|
pParams->iso[i]);
|
#endif
|
LOGD_ANR(" ratio:%f, offset:%f medRatio1\n",
|
pParams->ratio[i],
|
pParams->offset[i]);
|
|
LOGD_ANR("step1_median_ratio:%f step1_bf_sigmaR:%f step1_bf_uvgain:%f step1_bf_ratio:%f\n",
|
pParams->medRatio1[i],
|
pParams->sigmaR1[i],
|
pParams->uvgain1[i],
|
pParams->bfRatio1[i]);
|
|
LOGD_ANR("step2_median_ratio:%f step2_bf_sigmaR:%f step2_bf_uvgain:%f step2_bf_ratio:%f\n",
|
pParams->medRatio2[i],
|
pParams->sigmaR2[i],
|
pParams->uvgain2[i],
|
pParams->bfRatio2[i]);
|
|
LOGD_ANR(" step3_bf_sigmaR:%f step3_bf_uvgain:%f step3_bf_ratio:%f\n",
|
pParams->sigmaR3[i],
|
pParams->uvgain3[i],
|
pParams->bfRatio3[i]);
|
|
LOGD_ANR(" kernel3x3: %f %f %f\n",
|
pParams->kernel_3x3_table[0],
|
pParams->kernel_3x3_table[1],
|
pParams->kernel_3x3_table[2]);
|
|
LOGD_ANR(" kernel5x5: %f %f %f %f %f\n",
|
pParams->kernel_5x5_talbe[0],
|
pParams->kernel_5x5_talbe[1],
|
pParams->kernel_5x5_talbe[2],
|
pParams->kernel_5x5_talbe[3],
|
pParams->kernel_5x5_talbe[4]);
|
|
LOGD_ANR(" kernel9x9: %f %f %f %f %f %f %f %f\n",
|
pParams->kernel_9x9_table[0],
|
pParams->kernel_9x9_table[1],
|
pParams->kernel_9x9_table[2],
|
pParams->kernel_9x9_table[3],
|
pParams->kernel_9x9_table[4],
|
pParams->kernel_9x9_table[5],
|
pParams->kernel_9x9_table[6],
|
pParams->kernel_9x9_table[7]);
|
|
LOGD_ANR("kernel_num:%d\n\n", pParams->kernel_9x9_num);
|
|
|
}
|
}
|
|
return ANR_RET_SUCCESS;
|
}
|
|
|
ANRresult_t uvnr_config_setting_param_json(RKAnr_Uvnr_Params_t *pParams, CalibDbV2_UVNR_t *pCalibdb, char* param_mode, char * snr_name)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
int tuning_idx = 0;
|
|
if(pParams == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pCalibdb == NULL){
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
res = uvnr_get_setting_idx_by_name_json(pCalibdb, snr_name, &tuning_idx);
|
if(res != ANR_RET_SUCCESS){
|
LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
|
}
|
|
res = init_uvnr_params_json(pParams, pCalibdb, tuning_idx);
|
|
return res;
|
|
}
|
|
float interpISO(int ISO_low, int ISO_high, float value_low, float value_high, int ISO, float value)
|
{
|
if (ISO <= ISO_low)
|
{
|
value = value_low;
|
}
|
else if (ISO >= ISO_high)
|
{
|
value = value_high;
|
}
|
else
|
{
|
value = float(ISO - ISO_low) / float(ISO_high - ISO_low) * (value_high - value_low) + value_low;
|
}
|
return value;
|
}
|
|
|
ANRresult_t select_uvnr_params_by_ISO(RKAnr_Uvnr_Params_t *stRKUVNrParams, RKAnr_Uvnr_Params_Select_t *stRKUVNrParamsSelected, ANRExpInfo_t *pExpInfo)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
int iso = 50;
|
if(stRKUVNrParams == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(stRKUVNrParamsSelected == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pExpInfo == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pExpInfo->mfnr_mode_3to1){
|
iso = pExpInfo->preIso[pExpInfo->hdr_mode];
|
}else{
|
iso = pExpInfo->arIso[pExpInfo->hdr_mode];
|
}
|
//È·¶¨isoµÈ¼¶
|
//rkuvnriso@50 100 200 400 800 1600 3200 6400 12800
|
// isogain: 1 2 4 8 16 32 64 128 256
|
// isoindex: 0 1 2 3 4 5 6 7 8
|
|
int isoIndex = 0;
|
int isoGainLow = 0;
|
int isoGainHigh = 0;
|
int isoIndexLow = 0;
|
int isoIndexHigh = 0;
|
int iso_div = 50;
|
int max_iso_step = MAX_ISO_STEP;
|
int i = 0;
|
|
#ifndef RK_SIMULATOR_HW
|
for ( i = 0; i < max_iso_step - 1 ; i++)
|
{
|
if (iso >= stRKUVNrParams->iso[i] && iso <= stRKUVNrParams->iso[i + 1])
|
{
|
isoGainLow = stRKUVNrParams->iso[i] ;
|
isoGainHigh = stRKUVNrParams->iso[i + 1];
|
isoIndexLow = i;
|
isoIndexHigh = i + 1;
|
isoIndex = isoIndexLow;
|
break;
|
}
|
}
|
|
if(i == max_iso_step - 1){
|
if(iso < stRKUVNrParams->iso[0] ) {
|
isoGainLow = stRKUVNrParams->iso[0];
|
isoGainHigh = stRKUVNrParams->iso[1];
|
isoIndexLow = 0;
|
isoIndexHigh = 1;
|
isoIndex = 0;
|
}
|
|
if(iso > stRKUVNrParams->iso[max_iso_step - 1] ) {
|
isoGainLow = stRKUVNrParams->iso[max_iso_step - 2] ;
|
isoGainHigh = stRKUVNrParams->iso[max_iso_step - 1];
|
isoIndexLow = max_iso_step - 2;
|
isoIndexHigh = max_iso_step - 1;
|
isoIndex = max_iso_step - 1;
|
}
|
}
|
#else
|
isoIndex = int(log(float(iso / iso_div)) / log(2.0f));
|
|
for (i = max_iso_step - 1; i >= 0; i--)
|
{
|
if (iso < iso_div * (2 << i))
|
{
|
isoGainLow = iso_div * (2 << (i)) / 2;
|
isoGainHigh = iso_div * (2 << i);
|
}
|
}
|
|
isoGainLow = MIN(isoGainLow, iso_div * (2 << max_iso_step));
|
isoGainHigh = MIN(isoGainHigh, iso_div * (2 << max_iso_step));
|
|
isoIndexHigh = (int)(log((float)isoGainHigh / iso_div) / log((float)2));
|
isoIndexLow = (int)(log((float)isoGainLow / iso_div) / log((float)2));
|
|
isoIndexLow = MIN(MAX(isoIndexLow, 0), max_iso_step - 1);
|
isoIndexHigh = MIN(MAX(isoIndexHigh, 0), max_iso_step - 1);
|
#endif
|
|
LOGD_ANR("%s:%d iso:%d high:%d low:%d \n",
|
__FUNCTION__, __LINE__,
|
iso, isoGainHigh, isoGainLow);
|
|
//È¡Êý
|
memcpy(stRKUVNrParamsSelected->select_iso, stRKUVNrParams->rkuvnrISO, sizeof(char) * 256);
|
//step0:uvgainÔ¤´¦Àí
|
stRKUVNrParamsSelected->ratio = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->ratio[isoIndexLow],
|
stRKUVNrParams->ratio[isoIndexHigh], iso, stRKUVNrParamsSelected->ratio);
|
stRKUVNrParamsSelected->offset = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->offset[isoIndexLow],
|
stRKUVNrParams->offset[isoIndexHigh], iso, stRKUVNrParamsSelected->offset);
|
//step1-ϲÉÑù1
|
//¾ùÖµ1
|
stRKUVNrParamsSelected->wStep1 = stRKUVNrParams->wStep1[isoIndex];
|
stRKUVNrParamsSelected->hStep1 = stRKUVNrParams->hStep1[isoIndex];
|
stRKUVNrParamsSelected->meanSize1 = stRKUVNrParams->meanSize1[isoIndex];
|
//ÖÐÖµ1
|
memcpy(stRKUVNrParamsSelected->nonMed1, stRKUVNrParams->nonMed1, sizeof(int) * 4);
|
stRKUVNrParamsSelected->medSize1 = stRKUVNrParams->medSize1[isoIndex];
|
stRKUVNrParamsSelected->medRatio1 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->medRatio1[isoIndexLow],
|
stRKUVNrParams->medRatio1[isoIndexHigh], iso, stRKUVNrParamsSelected->medRatio1);
|
stRKUVNrParamsSelected->isMedIIR1 = stRKUVNrParams->isMedIIR1[isoIndex];
|
//Ë«±ß1
|
memcpy(stRKUVNrParamsSelected->nonBf1, stRKUVNrParams->nonBf1, sizeof(int) * 4);
|
stRKUVNrParamsSelected->bfSize1 = stRKUVNrParams->bfSize1[isoIndex];
|
stRKUVNrParamsSelected->sigmaR1 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaR1[isoIndexLow],
|
stRKUVNrParams->sigmaR1[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaR1);
|
stRKUVNrParamsSelected->sigmaD1 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaD1[isoIndexLow],
|
stRKUVNrParams->sigmaD1[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaD1);
|
stRKUVNrParamsSelected->uvgain1 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->uvgain1[isoIndexLow],
|
stRKUVNrParams->uvgain1[isoIndexHigh], iso, stRKUVNrParamsSelected->uvgain1);
|
stRKUVNrParamsSelected->bfRatio1 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->bfRatio1[isoIndexLow],
|
stRKUVNrParams->bfRatio1[isoIndexHigh], iso, stRKUVNrParamsSelected->bfRatio1);
|
stRKUVNrParamsSelected->isRowIIR1 = stRKUVNrParams->isRowIIR1[isoIndex];
|
stRKUVNrParamsSelected->isYcopy1 = stRKUVNrParams->isYcopy1[isoIndex];
|
|
//step2-ϲÉÑù2
|
memcpy(stRKUVNrParamsSelected->block2_ext, stRKUVNrParams->block2_ext, sizeof(int) * 4);
|
//¾ùÖµ2
|
stRKUVNrParamsSelected->wStep2 = stRKUVNrParams->wStep2[isoIndex];
|
stRKUVNrParamsSelected->hStep2 = stRKUVNrParams->hStep2[isoIndex];
|
stRKUVNrParamsSelected->meanSize2 = stRKUVNrParams->meanSize2[isoIndex];
|
//ÖÐÖµ2
|
memcpy(stRKUVNrParamsSelected->nonMed2, stRKUVNrParams->nonMed2, sizeof(int) * 4);
|
stRKUVNrParamsSelected->medSize2 = stRKUVNrParams->medSize2[isoIndex];
|
stRKUVNrParamsSelected->medRatio2 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->medRatio2[isoIndexLow],
|
stRKUVNrParams->medRatio2[isoIndexHigh], iso, stRKUVNrParamsSelected->medRatio2);
|
stRKUVNrParamsSelected->isMedIIR2 = stRKUVNrParams->isMedIIR2[isoIndex];
|
//Ë«±ß2
|
memcpy(stRKUVNrParamsSelected->nonBf2, stRKUVNrParams->nonBf2, sizeof(int) * 4);
|
stRKUVNrParamsSelected->bfSize2 = stRKUVNrParams->bfSize2[isoIndex];
|
stRKUVNrParamsSelected->sigmaR2 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaR2[isoIndexLow],
|
stRKUVNrParams->sigmaR2[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaR2);
|
stRKUVNrParamsSelected->sigmaD2 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaD2[isoIndexLow],
|
stRKUVNrParams->sigmaD2[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaD2);
|
stRKUVNrParamsSelected->uvgain2 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->uvgain2[isoIndexLow],
|
stRKUVNrParams->uvgain2[isoIndexHigh], iso, stRKUVNrParamsSelected->uvgain2);
|
stRKUVNrParamsSelected->bfRatio2 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->bfRatio2[isoIndexLow],
|
stRKUVNrParams->bfRatio2[isoIndexHigh], iso, stRKUVNrParamsSelected->bfRatio2);
|
stRKUVNrParamsSelected->isRowIIR2 = stRKUVNrParams->isRowIIR2[isoIndex];
|
stRKUVNrParamsSelected->isYcopy2 = stRKUVNrParams->isYcopy2[isoIndex];
|
|
//step3
|
memcpy(stRKUVNrParamsSelected->nonBf3, stRKUVNrParams->nonBf3, sizeof(int) * 4);
|
//Ë«±ß3
|
stRKUVNrParamsSelected->bfSize3 = stRKUVNrParams->bfSize3[isoIndex];
|
stRKUVNrParamsSelected->sigmaR3 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaR3[isoIndexLow],
|
stRKUVNrParams->sigmaR3[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaR3);
|
stRKUVNrParamsSelected->sigmaD3 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->sigmaD3[isoIndexLow],
|
stRKUVNrParams->sigmaD3[isoIndexHigh], iso, stRKUVNrParamsSelected->sigmaD3);
|
stRKUVNrParamsSelected->uvgain3 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->uvgain3[isoIndexLow],
|
stRKUVNrParams->uvgain3[isoIndexHigh], iso, stRKUVNrParamsSelected->uvgain3);
|
stRKUVNrParamsSelected->bfRatio3 = interpISO(isoGainLow, isoGainHigh, stRKUVNrParams->bfRatio3[isoIndexLow],
|
stRKUVNrParams->bfRatio3[isoIndexHigh], iso, stRKUVNrParamsSelected->bfRatio3);
|
stRKUVNrParamsSelected->isRowIIR3 = stRKUVNrParams->isRowIIR3[isoIndex];
|
stRKUVNrParamsSelected->isYcopy3 = stRKUVNrParams->isYcopy3[isoIndex];
|
|
//kernels
|
memcpy(stRKUVNrParamsSelected->kernel_3x3_table, stRKUVNrParams->kernel_3x3_table, sizeof(float) * 3);
|
memcpy(stRKUVNrParamsSelected->kernel_5x5_table, stRKUVNrParams->kernel_5x5_talbe, sizeof(float) * 5);
|
memcpy(stRKUVNrParamsSelected->kernel_9x9_table, stRKUVNrParams->kernel_9x9_table, sizeof(float) * 8);
|
stRKUVNrParamsSelected->kernel_9x9_num = stRKUVNrParams->kernel_9x9_num;
|
|
//curves
|
memcpy(stRKUVNrParamsSelected->sigmaAdj_x, stRKUVNrParams->sigmaAdj_x, sizeof(int) * 9);
|
memcpy(stRKUVNrParamsSelected->sigmaAdj_y, stRKUVNrParams->sigamAdj_y, sizeof(float) * 9);
|
memcpy(stRKUVNrParamsSelected->threAdj_x, stRKUVNrParams->threAdj_x, sizeof(int) * 9);
|
memcpy(stRKUVNrParamsSelected->threAdj_y, stRKUVNrParams->threAjd_y, sizeof(int) * 9);
|
|
return ANR_RET_SUCCESS;
|
|
}
|
|
|
ANRresult_t uvnr_fix_transfer(RKAnr_Uvnr_Params_Select_t *uvnr, RKAnr_Uvnr_Fix_t *pNrCfg, ANRExpInfo_t *pExpInfo, float gain_ratio, float fStrength)
|
{
|
LOGI_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
|
|
int i = 0;
|
ANRresult_t res = ANR_RET_SUCCESS;
|
|
if(uvnr == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pNrCfg == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pExpInfo == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
int iso = pExpInfo->arIso[pExpInfo->hdr_mode] * gain_ratio;
|
|
int log2e = (int)(0.8493f * (1 << RKUVNR_log2e));
|
log2e = log2e * (1 << RKUVNR_imgBit_set);
|
|
//0x0080
|
pNrCfg->uvnr_step1_en = 1;
|
pNrCfg->uvnr_step2_en = 1;
|
pNrCfg->nr_gain_en = 1;
|
pNrCfg->uvnr_nobig_en = 0;
|
pNrCfg->uvnr_big_en = 0;
|
|
|
//0x0084
|
pNrCfg->uvnr_gain_1sigma = (unsigned char)(uvnr->ratio * (1 << RKUVNR_ratio));
|
|
//0x0088
|
pNrCfg->uvnr_gain_offset = (unsigned char)(uvnr->offset * (1 << RKUVNR_offset));
|
|
//0x008c
|
pNrCfg->uvnr_gain_uvgain[0] = (unsigned char)(uvnr->uvgain1 * fStrength * (1 << RKUVNR_uvgain));
|
if( pNrCfg->uvnr_gain_uvgain[0] > 0x7f){
|
pNrCfg->uvnr_gain_uvgain[0] = 0x7f;
|
}
|
pNrCfg->uvnr_gain_uvgain[1] = (unsigned char)(uvnr->uvgain3 * fStrength * (1 << RKUVNR_uvgain));
|
if( pNrCfg->uvnr_gain_uvgain[1] > 0x7f){
|
pNrCfg->uvnr_gain_uvgain[1] = 0x7f;
|
}
|
pNrCfg->uvnr_gain_t2gen = (unsigned char)(uvnr->uvgain2 * fStrength * (1 << RKUVNR_uvgain));
|
if( pNrCfg->uvnr_gain_t2gen > 0x7f){
|
pNrCfg->uvnr_gain_t2gen = 0x7f;
|
}
|
pNrCfg->uvnr_gain_iso = (int)(sqrt(50.0 / (float)(iso)) * (1 << RKUVNR_gainRatio));
|
if(pNrCfg->uvnr_gain_iso > 0x80) {
|
pNrCfg->uvnr_gain_iso = 0x80;
|
}
|
|
if(pNrCfg->uvnr_gain_iso < 0x8) {
|
pNrCfg->uvnr_gain_iso = 0x8;
|
}
|
|
//0x0090
|
pNrCfg->uvnr_t1gen_m3alpha = (uvnr->medRatio1 * (1 << RKUVNR_medRatio));
|
|
//0x0094
|
pNrCfg->uvnr_t1flt_mode = uvnr->kernel_9x9_num;
|
|
//0x0098
|
pNrCfg->uvnr_t1flt_msigma = (unsigned short)(log2e / uvnr->sigmaR1);
|
|
pNrCfg->uvnr_t1flt_msigma = MIN(pNrCfg->uvnr_t1flt_msigma, 8191);
|
|
|
//0x009c
|
pNrCfg->uvnr_t1flt_wtp = (unsigned char)(uvnr->bfRatio1 * (1 << RKUVNR_bfRatio));
|
|
//0x00a0-0x00a4
|
for(i = 0; i < 8; i++) {
|
pNrCfg->uvnr_t1flt_wtq[i] = (unsigned char)(uvnr->kernel_9x9_table[i] * (1 << RKUVNR_kernels));
|
}
|
|
//0x00a8
|
pNrCfg->uvnr_t2gen_m3alpha = (unsigned char)(uvnr->medRatio2 * (1 << RKUVNR_medRatio));
|
|
//0x00ac
|
pNrCfg->uvnr_t2gen_msigma = (unsigned short)(log2e / uvnr->sigmaR2);
|
pNrCfg->uvnr_t2gen_msigma = MIN(pNrCfg->uvnr_t2gen_msigma, 8191);
|
|
|
//0x00b0
|
pNrCfg->uvnr_t2gen_wtp = (unsigned char)(uvnr->kernel_5x5_table[0] * (1 << RKUVNR_kernels));
|
|
//0x00b4
|
for(i = 0; i < 4; i++) {
|
pNrCfg->uvnr_t2gen_wtq[i] = (unsigned char)(uvnr->kernel_5x5_table[i + 1] * (1 << RKUVNR_kernels));
|
}
|
|
//0x00b8
|
pNrCfg->uvnr_t2flt_msigma = (unsigned short)(log2e / uvnr->sigmaR3);
|
pNrCfg->uvnr_t2flt_msigma = MIN(pNrCfg->uvnr_t2flt_msigma, 8191);
|
|
//0x00bc
|
pNrCfg->uvnr_t2flt_wtp = (unsigned char)(uvnr->bfRatio3 * (1 << RKUVNR_bfRatio));
|
for(i = 0; i < 3; i++) {
|
pNrCfg->uvnr_t2flt_wt[i] = (unsigned char)(uvnr->kernel_3x3_table[i] * (1 << RKUVNR_kernels));
|
}
|
|
#if UVNR_FIX_VALUE_PRINTF
|
uvnr_fix_Printf(pNrCfg);
|
#endif
|
|
LOGI_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
|
|
return ANR_RET_SUCCESS;
|
}
|
|
|
ANRresult_t uvnr_fix_Printf(RKAnr_Uvnr_Fix_t * pNrCfg)
|
{
|
int i = 0;
|
LOGI_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
|
|
ANRresult_t res = ANR_RET_SUCCESS;
|
|
if(pNrCfg == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
//0x0080
|
LOGD_ANR("(0x0080) uvnr_step1_en:%d uvnr_step2_en:%d nr_gain_en:%d uvnr_nobig_en:%d uvnr_big_en:%d\n",
|
pNrCfg->uvnr_step1_en,
|
pNrCfg->uvnr_step2_en,
|
pNrCfg->nr_gain_en,
|
pNrCfg->uvnr_nobig_en,
|
pNrCfg->uvnr_big_en);
|
|
//0x0084
|
LOGD_ANR("(0x0084) uvnr_gain_1sigma:%d \n",
|
pNrCfg->uvnr_gain_1sigma);
|
|
//0x0088
|
LOGD_ANR("(0x0088) uvnr_gain_offset:%d \n",
|
pNrCfg->uvnr_gain_offset);
|
|
//0x008c
|
LOGD_ANR("uvnr: (0x008c) uvnr_gain_uvgain:%d uvnr_step2_en:%d uvnr_gain_t2gen:%d uvnr_gain_iso:%d\n",
|
pNrCfg->uvnr_gain_uvgain[0],
|
pNrCfg->uvnr_gain_uvgain[1],
|
pNrCfg->uvnr_gain_t2gen,
|
pNrCfg->uvnr_gain_iso);
|
|
|
//0x0090
|
LOGD_ANR("(0x0090) uvnr_t1gen_m3alpha:%d \n",
|
pNrCfg->uvnr_t1gen_m3alpha);
|
|
//0x0094
|
LOGD_ANR("(0x0094) uvnr_t1flt_mode:%d \n",
|
pNrCfg->uvnr_t1flt_mode);
|
|
//0x0098
|
LOGD_ANR("(0x0098) uvnr_t1flt_msigma:%d \n",
|
pNrCfg->uvnr_t1flt_msigma);
|
|
//0x009c
|
LOGD_ANR("(0x009c) uvnr_t1flt_wtp:%d \n",
|
pNrCfg->uvnr_t1flt_wtp);
|
|
//0x00a0-0x00a4
|
for(i = 0; i < 8; i++) {
|
LOGD_ANR("(0x00a0-0x00a4) uvnr_t1flt_wtq[%d]:%d \n",
|
i, pNrCfg->uvnr_t1flt_wtq[i]);
|
}
|
|
//0x00a8
|
LOGD_ANR("(0x00a8) uvnr_t2gen_m3alpha:%d \n",
|
pNrCfg->uvnr_t2gen_m3alpha);
|
|
//0x00ac
|
LOGD_ANR("(0x00ac) uvnr_t2gen_msigma:%d \n",
|
pNrCfg->uvnr_t2gen_msigma);
|
|
//0x00b0
|
LOGD_ANR("(0x00b0) uvnr_t2gen_wtp:%d \n",
|
pNrCfg->uvnr_t2gen_wtp);
|
|
//0x00b4
|
for(i = 0; i < 4; i++) {
|
LOGD_ANR("(0x00b4) uvnr_t2gen_wtq[%d]:%d \n",
|
i, pNrCfg->uvnr_t2gen_wtq[i]);
|
}
|
|
//0x00b8
|
LOGD_ANR("(0x00b8) uvnr_t2flt_msigma:%d \n",
|
pNrCfg->uvnr_t2flt_msigma);
|
|
//0x00bc
|
LOGD_ANR("(0x00bc) uvnr_t2flt_wtp:%d \n",
|
pNrCfg->uvnr_t2flt_wtp);
|
for(i = 0; i < 3; i++) {
|
LOGD_ANR("(0x00bc) uvnr_t2flt_wt[%d]:%d \n",
|
i, pNrCfg->uvnr_t2flt_wt[i]);
|
}
|
|
|
LOGD_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
|
|
return ANR_RET_SUCCESS;
|
}
|
|
|
ANRresult_t uvnr_calibdbV2_assign(CalibDbV2_UVNR_t *pDst, CalibDbV2_UVNR_t *pSrc)
|
{
|
ANRresult_t res = ANR_RET_SUCCESS;
|
CalibDbV2_UVNR_TuningPara_t *pSrcTuningParaV2 = NULL;
|
CalibDbV2_UVNR_TuningPara_t *pDstTuningParaV2 = NULL;
|
int setting_len =0;
|
int iso_len = 0;
|
|
|
if(pDst == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
if(pSrc == NULL) {
|
LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
|
return ANR_RET_NULL_POINTER;
|
}
|
|
uvnr_calibdbV2_free(pDst);
|
|
pSrcTuningParaV2 = &pSrc->TuningPara;
|
pDstTuningParaV2 = &pDst->TuningPara;
|
|
//assign the value
|
pDst->Version = strdup(pSrc->Version);
|
pDstTuningParaV2->enable = pSrcTuningParaV2->enable;
|
|
//malloc iso size
|
setting_len = pSrcTuningParaV2->Setting_len;
|
pDstTuningParaV2->Setting = (CalibDbV2_UVNR_TuningPara_Setting_t *)malloc(setting_len * sizeof(CalibDbV2_UVNR_TuningPara_Setting_t));
|
memset(pDstTuningParaV2->Setting, 0x00, setting_len * sizeof(CalibDbV2_UVNR_TuningPara_Setting_t));
|
pDstTuningParaV2->Setting_len = setting_len;
|
|
for(int i=0; i<setting_len; i++){
|
iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
|
pDstTuningParaV2->Setting[i].Tuning_ISO = (CalibDbV2_UVNR_TuningPara_Setting_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_UVNR_TuningPara_Setting_ISO_t));
|
memset(pDstTuningParaV2->Setting[i].Tuning_ISO, 0x00, iso_len * sizeof(CalibDbV2_UVNR_TuningPara_Setting_ISO_t));
|
pDstTuningParaV2->Setting[i].Tuning_ISO_len = iso_len;
|
}
|
|
for(int i=0; i<setting_len; i++){
|
iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
|
pDstTuningParaV2->Setting[i].SNR_Mode = strdup(pSrcTuningParaV2->Setting[i].SNR_Mode);
|
pDstTuningParaV2->Setting[i].Sensor_Mode = strdup(pSrcTuningParaV2->Setting[i].Sensor_Mode);
|
|
for(int j=0; j<iso_len; j++){
|
pDstTuningParaV2->Setting[i].Tuning_ISO[j] = pSrcTuningParaV2->Setting[i].Tuning_ISO[j];
|
}
|
}
|
|
pDstTuningParaV2->Kernel_Coeff = pSrcTuningParaV2->Kernel_Coeff;
|
|
return res;
|
|
}
|
|
|
|
void uvnr_calibdbV2_free(CalibDbV2_UVNR_t *pCalibdbV2)
|
{
|
if(pCalibdbV2){
|
if(pCalibdbV2->Version){
|
free(pCalibdbV2->Version);
|
}
|
|
if(pCalibdbV2->TuningPara.Setting){
|
for(int i=0; i<pCalibdbV2->TuningPara.Setting_len; i++){
|
if(pCalibdbV2->TuningPara.Setting[i].SNR_Mode){
|
free(pCalibdbV2->TuningPara.Setting[i].SNR_Mode);
|
}
|
if(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode){
|
free(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode);
|
}
|
if(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO){
|
free(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO);
|
}
|
}
|
free(pCalibdbV2->TuningPara.Setting);
|
}
|
|
}
|
}
|
|
|
RKAIQ_END_DECLARE
|
