/*
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "RkAiqCalibDbV2.h"
#include "cJSON_Utils.h"
#include "j2s.h"
#include "RkAiqCalibDbV2Helper.h"
#include <fstream>

#ifndef __ANDROID__
#define IQ_DEBUG
#endif

#define CamCalibDbProj_JSON "CamCalibDbProj_t"
#define CamCalibDbContextV2_JSON "CamCalibDbV2Context_t"
#define JSON_PATCH_PATH "path"
#define JSON_PATCH_VALUE "value"

CamCalibDbV2Context_t* calibdbV2_ctx_new() {
    void* calib_scene = NULL;

    if (CHECK_ISP_HW_V20()) {
        calib_scene = new CamCalibDbV2ContextIsp20_t();
        memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp20_t));
    } else if (CHECK_ISP_HW_V21()) {
        calib_scene = new CamCalibDbV2ContextIsp21_t();
        memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp21_t));
    } else {
        XCAM_LOG_ERROR("not supported ISP plateform");
        return NULL;
    }

    CamCalibDbV2Context_t* calib_ctx = new CamCalibDbV2Context_t();
    calib_ctx->calib_scene = (char*)calib_scene;

    calib_ctx->sensor_info = new CalibDb_Sensor_ParaV2_t();
    memset(calib_ctx->sensor_info, 0, sizeof(CalibDb_Sensor_ParaV2_t));

    calib_ctx->module_info = new CalibDb_Module_ParaV2_t();
    memset(calib_ctx->module_info, 0, sizeof(CalibDb_Module_ParaV2_t));

    calib_ctx->sys_cfg = new CalibDb_SysStaticCfg_ParaV2_t();
    memset(calib_ctx->sys_cfg, 0, sizeof(CalibDb_SysStaticCfg_ParaV2_t));

    return calib_ctx;
}

void calibdbV2_ctx_delete(CamCalibDbV2Context_t* calib_ctx) {
    if (calib_ctx->calib_scene)
        delete calib_ctx->calib_scene;
    if (calib_ctx->sensor_info)
        delete calib_ctx->sensor_info;
    if (calib_ctx->module_info)
        delete calib_ctx->module_info;
    if (calib_ctx->sys_cfg)
        delete calib_ctx->sys_cfg;
    delete calib_ctx;
}

namespace RkCam {

std::map<std::string, CamCalibDbProj_t *> RkAiqCalibDbV2::mCalibDbsMap;
std::mutex RkAiqCalibDbV2::calib_mutex;

CamCalibDbV2Context_t *RkAiqCalibDbV2::CalibV2Alloc() {
    CamCalibDbV2Context_t *calibv2 = calibdbV2_ctx_new();

    if (!calibv2) {
        XCAM_LOG_ERROR("malloc for new calibv2 failed.");
        return nullptr;
    }
    //memset(calibv2, 0, calibdbV2_ctx_size(calibv2));

    return calibv2;
}

int RkAiqCalibDbV2::CalibV2Free(CamCalibDbV2Context_t *calibv2) {
    if (calibv2) {
        // TODO: free calibv2 internal space which allocated by j2s
        calibdbV2_ctx_delete(calibv2);
    } else {
        XCAM_LOG_WARNING("try to free an empty calibv2");
    }

    return 0;
}

CamCalibDbProj_t *RkAiqCalibDbV2::CamCalibDbProjAlloc() {
    CamCalibDbProj_t *calibproj =
        (CamCalibDbProj_t *)malloc(sizeof(CamCalibDbProj_t));
    if (!calibproj) {
        XCAM_LOG_ERROR("malloc for new calibv2 failed.");
        return nullptr;
    }
    memset(calibproj, 0, sizeof(CamCalibDbProj_t));

    return calibproj;
}

void calib_free(void *ptr)
{
    if (ptr)
        free(ptr);
}

int RkAiqCalibDbV2::CamCalibDbProjFree(CamCalibDbProj_t *calibproj) {
    if (calibproj) {
        CamCalibDbFreeSensorCtx(&calibproj->sensor_calib);
        for (int i = 0; i < calibproj->main_scene_len; i++) {
            CamCalibMainSceneList_t* main_scene = calibproj->main_scene + i;
            if (main_scene->name)
                calib_free(main_scene->name);
            for (int j = 0; j < main_scene->sub_scene_len; j++) {
                CamCalibSubSceneList_t* sub_scene = main_scene->sub_scene + j;
                CamCalibDbFreeSceneCtx(calibdbv2_get_scene_ptr(sub_scene));
                if (sub_scene->name)
                    calib_free(sub_scene->name);
            }
            calib_free(main_scene->sub_scene);
        }
        if (calibproj->main_scene)
            calib_free(calibproj->main_scene);
        if (calibproj->uapi) {
            for (int i = 0; i < calibproj->uapi_len; i++)
                CamCalibDbFreeUapiCtx(calibproj->uapi + i);
            calib_free(calibproj->uapi);
        }
        CamCalibDbFreeSysStaticCtx(&calibproj->sys_static_cfg);
        free(calibproj);
    } else {
        XCAM_LOG_WARNING("try to free an empty CamCalibDbProj_t");
    }

    return 0;
}

CamCalibDbV2Context_t *RkAiqCalibDbV2::json2calib(const char *jsfile) {
#if 0
    j2s_ctx ctx;
    int ret = -1;

    j2s_init(&ctx);
    ctx.format_json = false;
    ctx.manage_data = false;

    CamCalibDbV2Context_t *calib = CalibV2Alloc();

    ret = j2s_json_file_to_struct(&ctx, jsfile,
                                  calibdbv2_get_ctx_struct_name(calib), calib);
    j2s_deinit(&ctx);

    if (ret) {
        CalibV2Free(calib);
        return nullptr;
    }

#ifdef IQ_DEBUG
    calib2json("/tmp/iq_dump.json", calib);
#endif

    return calib;
#else
    // TODO
    return NULL;
#endif
}

CamCalibDbProj_t *RkAiqCalibDbV2::json2calibproj(const char *jsfile) {
    j2s_ctx ctx;
    int ret = -1;

    j2s_init(&ctx);
    ctx.format_json = false;
    ctx.manage_data = false;

    CamCalibDbProj_t *calibproj = CamCalibDbProjAlloc();

    ret = j2s_json_file_to_root_struct(&ctx, jsfile, calibproj);
    j2s_deinit(&ctx);

    if (ret) {
        CamCalibDbProjFree(calibproj);
        return nullptr;
    }

#ifdef IQ_DEBUG
    calibproj2json("/tmp/iq_dump.json", calibproj);
#endif

    return calibproj;
}

int RkAiqCalibDbV2::calibproj2json(const char *jsfile,
                                   CamCalibDbProj_t *calibproj) {
    char *json_buff = NULL;
    j2s_ctx ctx;

    ctx.format_json = true;
    ctx.manage_data = false;

    if (0 != access(jsfile, F_OK)) {
        XCAM_LOG_INFO("Calibproj file already %s exist, oaverride now!", jsfile);
    }

    std::ofstream ofile(jsfile);
    if (ofile.fail()) {
        XCAM_LOG_ERROR("write %s failed!", jsfile);
        return -1;
    }

    j2s_init(&ctx);
    json_buff = j2s_dump_root_struct(&ctx, calibproj);
    j2s_deinit(&ctx);

    if (!json_buff) {
        XCAM_LOG_ERROR("create %s failed.", jsfile);
        return -1;
    }

    ofile << json_buff;

    free(json_buff);

    return 0;
}

int RkAiqCalibDbV2::calib2json(const char *jsfile,
                               CamCalibDbV2Context_t *calib) {
    char *json_buff = NULL;
    j2s_ctx ctx;

    ctx.format_json = true;

    if (0 != access(jsfile, F_OK)) {
        XCAM_LOG_INFO("Calib file already %s exist, oaverride now!", jsfile);
    }

    std::ofstream ofile(jsfile);
    if (ofile.fail()) {
        XCAM_LOG_ERROR("write %s failed!", jsfile);
        return -1;
    }

    j2s_init(&ctx);
    json_buff = j2s_dump_struct(&ctx, calibdbv2_get_scene_ctx_struct_name(calib), calib->calib_scene);
    j2s_deinit(&ctx);

    if (!json_buff) {
        XCAM_LOG_ERROR("create %s failed.", jsfile);
        return -1;
    }

    ofile << json_buff;

    free(json_buff);

    return 0;
}

CamCalibDbV2Context_t *RkAiqCalibDbV2::cjson2calib(cJSON *json) {
    j2s_ctx ctx;
    int ret = -1;

    j2s_init(&ctx);
    ctx.format_json = false;
    ctx.manage_data = false;

    CamCalibDbV2Context_t *calib = CalibV2Alloc();

    ret = j2s_json_to_struct(&ctx, json, calibdbv2_get_scene_ctx_struct_name(calib), calib->calib_scene);
    j2s_deinit(&ctx);

    if (ret) {
        CalibV2Free(calib);
        return nullptr;
    }

    return calib;
}

cJSON *RkAiqCalibDbV2::calib2cjson(const CamCalibDbV2Context_t *calib) {
    cJSON *json = NULL;
    j2s_ctx ctx;

    j2s_init(&ctx);
    json = j2s_struct_to_json(&ctx, calibdbv2_get_scene_ctx_struct_name(calib), (void *)calib->calib_scene);
    j2s_deinit(&ctx);

    if (!json) {
        XCAM_LOG_ERROR("%s failed.", __func__);
        return nullptr;
    }

    return json;
}

CamCalibDbProj_t *RkAiqCalibDbV2::createCalibDbProj(const char *jsfile) {
    std::map<std::string, CamCalibDbProj_t *>::iterator it;
    std::string str(jsfile);
    const std::lock_guard<std::mutex> lock(RkAiqCalibDbV2::calib_mutex);

    it = mCalibDbsMap.find(str);
    if (it != mCalibDbsMap.end()) {
        XCAM_LOG_INFO("use cached calibdb for %s!", jsfile);
        return it->second;
    } else {
        if (0 != access(jsfile, F_OK)) {
            XCAM_LOG_ERROR("access %s failed!", jsfile);
            return nullptr;
        }

        CamCalibDbProj_t *calibproj = json2calibproj(jsfile);

        if (calibproj) {
            mCalibDbsMap[str] = calibproj;
            XCAM_LOG_INFO("create calibdb from %s success.", jsfile);
            return calibproj;
        } else {
            XCAM_LOG_ERROR("parse %s failed.", jsfile);
            return nullptr;
        }
    }
}

void RkAiqCalibDbV2::releaseCalibDbProj() {
    std::map<std::string, CamCalibDbProj_t *>::iterator it;
    for (it = mCalibDbsMap.begin(); it != mCalibDbsMap.end(); it++) {
        CamCalibDbProj_t *calibproj = it->second;
        if (calibproj) {
            CamCalibDbProjFree(calibproj);
        }
    }
    mCalibDbsMap.clear();
}

CamCalibDbV2Context_t
RkAiqCalibDbV2::toDefaultCalibDb(CamCalibDbProj_t *calibproj) {
    CamCalibDbV2Context_t ctx;
    memset(&ctx, 0, sizeof(CamCalibDbV2Context_t));
    if (!calibproj || !calibproj->main_scene ||
            !calibproj->main_scene[0].sub_scene) {
        XCAM_LOG_ERROR("CamCalibDbProj in invalied!");
        return ctx;
    }
    ctx.calib_scene = (char*)(calibdbv2_get_scene_ptr(&calibproj->main_scene[0].sub_scene[0]));
    ctx.sensor_info = &calibproj->sensor_calib;
    ctx.module_info = &calibproj->module_calib;
    ctx.sys_cfg = &calibproj->sys_static_cfg;

    return ctx;
}

CamCalibDbV2Context_t *
RkAiqCalibDbV2::applyPatch(const CamCalibDbV2Context_t *calib, cJSON *patch) {
    cJSON *base_json = NULL;
    int ret = -1;

    if (!calib || !patch) {
        XCAM_LOG_ERROR("%s input invalied!", __func__);
        return nullptr;
    }

    base_json = calib2cjson(calib);

    if (!base_json) {
        XCAM_LOG_ERROR("%s conver failed!", __func__);
        return nullptr;
    }

    ret = cJSONUtils_ApplyPatches(base_json, patch);
    if (0 != ret) {
        XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
        return nullptr;
    }

    return cjson2calib(base_json);
}

CamCalibDbV2Context_t *
RkAiqCalibDbV2::applyPatch(const CamCalibDbV2Context_t *calib,
                           const char *patch_str) {
    cJSON *patch_json = NULL;

    patch_json = cJSON_Parse(patch_str);

    return applyPatch(calib, patch_json);
}

CamCalibDbV2Context_t *
RkAiqCalibDbV2::applyPatch2(const CamCalibDbV2Context_t *calib, cJSON *patch) {
  CamCalibDbV2Context_t *new_calib = NULL;
  cJSON *base_json = NULL;
  cJSON *arr_item = NULL;
  j2s_ctx ctx;
  ctx.format_json = true;
  int change_sum = 0;
  int ret = -1;

  if (!calib || !patch) {
    XCAM_LOG_ERROR("%s input invalied!", __func__);
    return nullptr;
  }

  change_sum = cJSON_GetArraySize(patch);

  if (change_sum <= 0) {
    XCAM_LOG_INFO("[Tuning]: analyz change failed!\n");
    return nullptr;
  }

  // check if not common info add "calib_scene" prefix to path
  arr_item = patch->child;

  for (int i = 0; i <= (change_sum - 1); ++i) {
    if (arr_item) {
      auto path_str = std::string(
          cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring);
      auto headless = path_str.substr(path_str.find_first_not_of("/"),
                                      path_str.find_last_not_of("/"));
      auto module_name = headless.substr(0, headless.find_first_of("/"));

      if (module_name.compare(std::string("sensor_calib")) == 0) {
        continue;
      } else if (module_name.compare(std::string("module_calib")) == 0) {
        continue;
      } else if (module_name.compare(std::string("sys_static_cfg")) == 0) {
        continue;
      }
      path_str = std::string("/calib_scene") + path_str;
      cJSON_ReplaceItemInObject(arr_item, JSON_PATCH_PATH,
                                cJSON_CreateString(path_str.c_str()));
    }
    arr_item = arr_item->next;
  }

  // convert CamCalibDbV2Context_t to CamCalibDbV2Tuning_t
  CamCalibDbV2Tuning_t tuning_base;
  memset(&tuning_base, 0, sizeof(CamCalibDbV2Tuning_t));
  calibdbV2_to_tuningdb(&tuning_base, calib);

  j2s_init(&ctx);
  base_json = j2s_struct_to_json(&ctx, "CamCalibDbV2Tuning_t", &tuning_base);

  if (!base_json) {
    XCAM_LOG_ERROR("create CamCalibDbV2Tuning_t failed.");
    goto patch_failed;
  }

  ret = cJSONUtils_ApplyPatches(base_json, patch);
  if (0 != ret) {
    XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
    goto patch_failed;
  }

  CamCalibDbV2Tuning_t tuning_patched;
  memset(&tuning_patched, 0, sizeof(CamCalibDbV2Tuning_t));
  ret = j2s_json_to_struct(&ctx, base_json, "CamCalibDbV2Tuning_t",
                           &tuning_patched);
  if (0 != ret) {
    XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
    goto patch_failed;
  }

  new_calib = CalibV2Alloc();
  calibdbV2_from_tuningdb(new_calib, &tuning_patched);

patch_failed:
  j2s_deinit(&ctx);

  if (base_json)
    cJSON_free(base_json);

  return new_calib;
}

CamCalibDbV2Context_t *
RkAiqCalibDbV2::applyPatchFile(const CamCalibDbV2Context_t *calib,
                               const char *patch_file) {
    size_t json_size = 0;
    char *json_str = NULL;

    json_str = (char *)j2s_read_file(patch_file, &json_size);

    return applyPatch(calib, json_str);
}

CamCalibDbV2Context_t *RkAiqCalibDbV2::applyPatch(const char *jsfile,
        const char *js_patch) {
    return NULL;
}

RkAiqAlgoType_t RkAiqCalibDbV2::string2algostype(const char *str) {
    static std::unordered_map<std::string, RkAiqAlgoType_t> const table = {
        {"sensor_calib", RK_AIQ_ALGO_TYPE_AE},
        {"module_calib", RK_AIQ_ALGO_TYPE_AE},
        {"ae_calib", RK_AIQ_ALGO_TYPE_AE},
        {"wb_v20", RK_AIQ_ALGO_TYPE_AWB},
        {"wb_v21", RK_AIQ_ALGO_TYPE_AWB},
        {"af_calib", RK_AIQ_ALGO_TYPE_AF},
        {"ablc_calib", RK_AIQ_ALGO_TYPE_ABLC},
        {"adpcc_calib", RK_AIQ_ALGO_TYPE_ADPCC},
        {"amerge_calib", RK_AIQ_ALGO_TYPE_AMERGE},
        {"atmo_calib", RK_AIQ_ALGO_TYPE_ATMO},
        {"anr_calib", RK_AIQ_ALGO_TYPE_ANR},
        {"lsc_v2", RK_AIQ_ALGO_TYPE_ALSC},
        {"agic_calib_v20", RK_AIQ_ALGO_TYPE_AGIC},
        {"agic_calib_v21", RK_AIQ_ALGO_TYPE_AGIC},
        {"adebayer_calib", RK_AIQ_ALGO_TYPE_ADEBAYER},
        {"ccm_calib", RK_AIQ_ALGO_TYPE_ACCM},
        {"agamma_calib", RK_AIQ_ALGO_TYPE_AGAMMA},
        {"awdr_calib", RK_AIQ_ALGO_TYPE_AWDR},
        {"adehaze_calib_v20", RK_AIQ_ALGO_TYPE_ADHAZ},
        {"adehaze_calib_v21", RK_AIQ_ALGO_TYPE_ADHAZ},
        {"lut3d_calib", RK_AIQ_ALGO_TYPE_A3DLUT},
        {"aldch", RK_AIQ_ALGO_TYPE_ALDCH},
        {"ar2y_calib", RK_AIQ_ALGO_TYPE_AR2Y},
        {"cproc", RK_AIQ_ALGO_TYPE_ACP},
        {"ie", RK_AIQ_ALGO_TYPE_AIE},
        {"sharp_v1", RK_AIQ_ALGO_TYPE_ASHARP},
        {"edgefilter_v1", RK_AIQ_ALGO_TYPE_ASHARP},
        {"aorb_calib", RK_AIQ_ALGO_TYPE_AORB},
        {"acgc_calib", RK_AIQ_ALGO_TYPE_ACGC},
        {"asd_calib", RK_AIQ_ALGO_TYPE_ASD},
        {"adrc_calib", RK_AIQ_ALGO_TYPE_ADRC},
        {"adegamma_calib", RK_AIQ_ALGO_TYPE_ADEGAMMA},

#if ANR_NO_SEPERATE_MARCO
        {"bayernr_v1", RK_AIQ_ALGO_TYPE_ANR},
        {"mfnr_v1", RK_AIQ_ALGO_TYPE_ANR},
        {"ynr_v1", RK_AIQ_ALGO_TYPE_ANR},
        {"uvnr_v1", RK_AIQ_ALGO_TYPE_ANR},
#else
        {"bayernr_v1", RK_AIQ_ALGO_TYPE_ARAWNR},
        {"mfnr_v1", RK_AIQ_ALGO_TYPE_AMFNR},
        {"ynr_v1", RK_AIQ_ALGO_TYPE_AYNR},
        {"uvnr_v1", RK_AIQ_ALGO_TYPE_ACNR},
#endif
        {"aeis_calib", RK_AIQ_ALGO_TYPE_AEIS},
        {"afec_calib", RK_AIQ_ALGO_TYPE_AFEC},

        //ror rk356x nr & sharp
        {"bayernr_v2", RK_AIQ_ALGO_TYPE_ARAWNR},
        {"ynr_v2", RK_AIQ_ALGO_TYPE_AYNR},
        {"cnr_v1", RK_AIQ_ALGO_TYPE_ACNR},
        {"sharp_v3", RK_AIQ_ALGO_TYPE_ASHARP},
    };

    auto it = table.find(std::string(str));
    if (it != table.end()) {
        return it->second;
    }

    return RK_AIQ_ALGO_TYPE_NONE;
}

ModuleNameList RkAiqCalibDbV2::analyzChange(cJSON *patch) {
    auto change_name_list = std::make_shared<std::list<std::string>>();
    cJSON *arr_item = NULL;
    int change_sum = 0;

    change_sum = cJSON_GetArraySize(patch);

    XCAM_LOG_INFO("[Tuning]: %d changes in this cmd!\n", change_sum);

    if (change_sum <= 0) {
        XCAM_LOG_INFO("[Tuning]: analyz change failed!\n");
        return nullptr;
    }

    arr_item = patch->child;

    for (int i = 0; i <= (change_sum - 1); ++i) {
        if (arr_item) {
            auto path_str = std::string(
                                cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring);
            auto headless = path_str.substr(path_str.find_first_not_of("/"),
                                            path_str.find_last_not_of("/"));
            auto calib_name = headless.substr(0, headless.find_first_of("/"));
            XCAM_LOG_INFO("[Tuning]: %s changed!\n", calib_name.c_str());
            change_name_list->push_back(calib_name);
        }
        arr_item = arr_item->next;
    }

    // Remove duplicated item
    change_name_list->sort();
    change_name_list->unique();

    return change_name_list;
}

RkAiqCalibDbV2::TuningCalib
RkAiqCalibDbV2::analyzTuningCalib(const CamCalibDbV2Context_t *calib,
                                  cJSON *patch) {
    TuningCalib tuning_calib;

    tuning_calib.ModuleNames = analyzChange(patch);
    tuning_calib.calib = applyPatch2(calib, patch);

    if (patch)
        cJSON_free(patch);

    return tuning_calib;
}

RkAiqCalibDbV2::TuningCalib
RkAiqCalibDbV2::analyzTuningCalib(const CamCalibDbV2Context_t *calib,
                                  const char *patch_str) {
    cJSON *patch_json = NULL;

    patch_json = cJSON_Parse(patch_str);

    return analyzTuningCalib(calib, patch_json);
}

cJSON *RkAiqCalibDbV2::readIQNode(const CamCalibDbV2Context_t *calib,
                                  const char *node_path) {
  cJSON *base_json = NULL;
  auto path_str = std::string(node_path);
  auto headless = path_str.substr(path_str.find_first_not_of("/"),
                                  path_str.find_last_not_of("/"));
  auto module_name = headless.substr(0, headless.find_first_of("/"));

  if (module_name.compare(std::string("sensor_calib")) == 0 ||
      module_name.compare(std::string("module_calib")) == 0 ||
      module_name.compare(std::string("sys_static_cfg")) == 0) {
    j2s_ctx ctx;
    ctx.format_json = true;
    CamCalibDbV2Tuning_t tuning_base;

    memset(&tuning_base, 0, sizeof(CamCalibDbV2Tuning_t));
    calibdbV2_to_tuningdb(&tuning_base, calib);

    j2s_init(&ctx);
    base_json = j2s_struct_to_json(&ctx, "CamCalibDbV2Tuning_t", &tuning_base);
    j2s_deinit(&ctx);
  } else {
    base_json = calib2cjson(calib);
  }

  if (!base_json) {
    XCAM_LOG_ERROR("%s conver failed!", __func__);
    return nullptr;
  }

  cJSON *node_json = cJSONUtils_GetPointer(base_json, node_path);
  if (node_json)
    cJSON_DetachItemViaPointer(base_json, node_json);

  cJSON_free(base_json);

  return node_json;
}

/**
 * @brief read json string from a json iq
 *
 * @param calib
 * @param node_path
 *
 * @return string buffer or NULL, must be free outside.
 */
char* RkAiqCalibDbV2::readIQNodeStr(const CamCalibDbV2Context_t* calib,
                                    const char* node_path) {
    cJSON* node_json = readIQNode(calib, node_path);
    if (!node_json) {
        XCAM_LOG_ERROR("%s find json node failed!", __func__);
        return nullptr;
    }

    return cJSON_PrintUnformatted(node_json);
}

char* RkAiqCalibDbV2::readIQNodeStrFromJstr(const CamCalibDbV2Context_t* calib,
        const char* json_str) {
    cJSON *request_json = NULL;
    cJSON *arr_item = NULL;
    char* ret_str = NULL;
    int request_sum = 0;

    cJSON *ret_json;
    ret_json = cJSON_CreateArray();

    request_json = cJSON_Parse(json_str);
    request_sum = cJSON_GetArraySize(request_json);

    if (request_sum <= 0) {
        XCAM_LOG_INFO("[Tuning]: analyz request failed!\n");
        return nullptr;
    }

    arr_item = request_json->child;

    for (int i = 0; i <= (request_sum - 1); ++i) {
        if (arr_item) {
            char* path_str = cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring;
            cJSON* ret_node = readIQNode(calib, path_str);
            if (ret_node) {
                cJSON* ret_item = cJSON_CreateObject();
                cJSON_AddStringToObject(ret_item, JSON_PATCH_PATH, path_str);
                cJSON_AddItemToObject(ret_item, JSON_PATCH_VALUE, ret_node);
                cJSON_AddItemToArray(ret_json, ret_item);
            }
        }
        arr_item = arr_item->next;
    }

    ret_str = cJSON_PrintUnformatted(ret_json);

    cJSON_free(ret_json);
    cJSON_free(request_json);

    return ret_str;
}

int RkAiqCalibDbV2::CamCalibDbFreeSysStaticCtx(CalibDb_SysStaticCfg_ParaV2_t* sys_static)
{
    CalibDb_AlgoSwitch_t* algoSwitch = &sys_static->algoSwitch;

    if (algoSwitch->enable_algos)
        calib_free(algoSwitch->enable_algos);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeUapiCtx(RkaiqUapi_t* uapi)
{
    RkaiqSysCtl_t* system = &uapi->system;
    aiq_scene_t* scene = &system->scene;
    if (scene->main_scene)
        calib_free(scene->main_scene);
    if (scene->sub_scene)
        calib_free(scene->sub_scene);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeSensorCtx(CalibDb_Sensor_ParaV2_t* sensor)
{
    CalibDb_AecGainRangeV2_t* Gain2Reg = &sensor->Gain2Reg;
    if (Gain2Reg->GainRange)
        calib_free(Gain2Reg->GainRange);
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeModuleCtx(CalibDb_Module_ParaV2_t* module)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeAeCtx(CalibDb_Aec_ParaV2_t* ae)
{
    CalibDb_LinearAE_AttrV2_t *LinearAeCtrl = &ae->LinearAeCtrl;
    CalibDb_LinAeRoute_AttrV2_t *Route = &LinearAeCtrl->Route;
    if (Route->TimeDot)
        calib_free(Route->TimeDot);
    if (Route->GainDot)
        calib_free(Route->GainDot);
    if (Route->IspDGainDot)
        calib_free(Route->IspDGainDot);
    if (Route->PIrisDot)
        calib_free(Route->PIrisDot);

    CalibDb_AecDynamicSetpointV2_t* DySetpoint = &LinearAeCtrl->DySetpoint;
    if (DySetpoint->ExpLevel)
        calib_free(DySetpoint->ExpLevel);
    if (DySetpoint->DySetpoint)
        calib_free(DySetpoint->DySetpoint);

    CalibDb_AecBacklightV2_t *BackLightCtrl = &LinearAeCtrl->BackLightCtrl;
    CalibDb_BacklitSetPointV2_t* BacklitSetPoint = &BackLightCtrl->BacklitSetPoint;
    if (BacklitSetPoint->ExpLevel)
        calib_free(BacklitSetPoint->ExpLevel);
    if (BacklitSetPoint->NonOEPdfTh)
        calib_free(BacklitSetPoint->NonOEPdfTh);
    if (BacklitSetPoint->LowLightPdfTh)
        calib_free(BacklitSetPoint->LowLightPdfTh);
    if (BacklitSetPoint->TargetLLLuma)
        calib_free(BacklitSetPoint->TargetLLLuma);

    CalibDb_AecOverExpCtrlV2_t* OverExpCtrl = &LinearAeCtrl->OverExpCtrl;
    CalibDb_OverExpSetPointV2_t* OverExpSetPoint = &OverExpCtrl->OverExpSetPoint;
    if (OverExpSetPoint->OEpdf)
        calib_free(OverExpSetPoint->OEpdf);
    if (OverExpSetPoint->LowLightWeight)
        calib_free(OverExpSetPoint->LowLightWeight);
    if (OverExpSetPoint->HighLightWeight)
        calib_free(OverExpSetPoint->HighLightWeight);

    CalibDb_HdrAE_AttrV2_t* HdrAeCtrl = &ae->HdrAeCtrl;
    CalibDb_ExpRatioCtrlV2_t* ExpRatioCtrl = &HdrAeCtrl->ExpRatioCtrl;
    CalibDb_ExpRatioV2_t* ExpRatio = &ExpRatioCtrl->ExpRatio;
    if (ExpRatio->RatioExpDot)
        calib_free(ExpRatio->RatioExpDot);
    if (ExpRatio->M2SRatioFix)
        calib_free(ExpRatio->M2SRatioFix);
    if (ExpRatio->L2MRatioFix)
        calib_free(ExpRatio->L2MRatioFix);
    if (ExpRatio->M2SRatioMax)
        calib_free(ExpRatio->M2SRatioMax);
    if (ExpRatio->L2MRatioMax)
        calib_free(ExpRatio->L2MRatioMax);

    CalibDb_HdrAeRoute_AttrV2_t* hdr_Route = &HdrAeCtrl->Route;
    if (hdr_Route->Frm0TimeDot)
        calib_free(hdr_Route->Frm0TimeDot);
    if (hdr_Route->Frm0GainDot)
        calib_free(hdr_Route->Frm0GainDot);
    if (hdr_Route->Frm0IspDGainDot)
        calib_free(hdr_Route->Frm0IspDGainDot);
    if (hdr_Route->Frm1TimeDot)
        calib_free(hdr_Route->Frm1TimeDot);
    if (hdr_Route->Frm1GainDot)
        calib_free(hdr_Route->Frm1GainDot);
    if (hdr_Route->Frm1IspDGainDot)
        calib_free(hdr_Route->Frm1IspDGainDot);
    if (hdr_Route->Frm2TimeDot)
        calib_free(hdr_Route->Frm2TimeDot);
    if (hdr_Route->Frm2GainDot)
        calib_free(hdr_Route->Frm2GainDot);
    if (hdr_Route->Frm2IspDGainDot)
        calib_free(hdr_Route->Frm2IspDGainDot);
    if (hdr_Route->PIrisDot)
        calib_free(hdr_Route->PIrisDot);

    CalibDb_LfrmCtrlV2_t* LframeCtrl = &HdrAeCtrl->LframeCtrl;
    CalibDb_LfrmSetPointV2_t* LfrmSetPoint = &LframeCtrl->LfrmSetPoint;
    if (LfrmSetPoint->LExpLevel)
        calib_free(LfrmSetPoint->LExpLevel);
    if (LfrmSetPoint->NonOEPdfTh)
        calib_free(LfrmSetPoint->NonOEPdfTh);
    if (LfrmSetPoint->LowLightPdfTh)
        calib_free(LfrmSetPoint->LowLightPdfTh);
    if (LfrmSetPoint->LSetPoint)
        calib_free(LfrmSetPoint->LSetPoint);
    if (LfrmSetPoint->TargetLLLuma)
        calib_free(LfrmSetPoint->TargetLLLuma);

    CalibDb_MfrmCtrlV2_t* MframeCtrl = &HdrAeCtrl->MframeCtrl;
    if (MframeCtrl->MExpLevel)
        calib_free(MframeCtrl->MExpLevel);
    if (MframeCtrl->MSetPoint)
        calib_free(MframeCtrl->MSetPoint);

    CalibDb_SfrmCtrlV2_t* SframeCtrl = &HdrAeCtrl->SframeCtrl;
    CalibDb_SfrmSetPointV2_t* SfrmSetPoint = &SframeCtrl->SfrmSetPoint;
    if (SfrmSetPoint->SExpLevel)
        calib_free(SfrmSetPoint->SExpLevel);
    if (SfrmSetPoint->SSetPoint)
        calib_free(SfrmSetPoint->SSetPoint);
    if (SfrmSetPoint->TargetHLLuma)
        calib_free(SfrmSetPoint->TargetHLLuma);

    CalibDb_AeSyncTestV2_t* SyncTest = &ae->SyncTest;
    CalibDb_AlterExpV2_t* AlterExp = &SyncTest->AlterExp;
    if (AlterExp->LinearAE)
        calib_free(AlterExp->LinearAE);
    if (AlterExp->HdrAE)
        calib_free(AlterExp->HdrAE);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeAwbV21Ctx(CalibDbV2_Wb_Para_V21_t* awb)
{
  CalibDbV2_Wb_Awb_Para_V21_t* autoPara = &awb->autoPara;
  if (autoPara->lsUsedForYuvDet) {
      for (int i = 0; i < autoPara->lsUsedForYuvDet_len; i++)
          calib_free(autoPara->lsUsedForYuvDet[i]);
  }
  calib_free(autoPara->lsUsedForYuvDet);

  CalibDbV2_Awb_Luma_Weight_t* wpDiffLumaWeight = &autoPara->wpDiffLumaWeight;
  if (wpDiffLumaWeight->wpDiffWeightLvSet) {
      for (int i = 0; i < wpDiffLumaWeight->wpDiffWeightLvSet_len; i++) {
        CalibDbV2_Awb_Luma_Weight_Lv_t* wpDiffWeightLvSet = wpDiffLumaWeight->wpDiffWeightLvSet + i;
        if (wpDiffWeightLvSet->ratioSet)
            calib_free(wpDiffWeightLvSet->ratioSet);
      }
      calib_free(wpDiffLumaWeight->wpDiffWeightLvSet);
  }

  if (autoPara->lightSources) {
      for (int i = 0; i < autoPara->lightSources_len; i++) {
        CalibDbV2_Awb_Light_V21_t* lightSource = autoPara->lightSources + i;
        calib_free(lightSource->name);
      }
      calib_free(autoPara->lightSources);
  }
  if(autoPara->limitRange.lumaValue)
    calib_free(autoPara->limitRange.lumaValue);
  if(autoPara->limitRange.maxB)
    calib_free(autoPara->limitRange.maxB);
  if(autoPara->limitRange.maxR)
    calib_free(autoPara->limitRange.maxR);
  if(autoPara->limitRange.maxG)
    calib_free(autoPara->limitRange.maxG);
  if(autoPara->limitRange.maxY)
    calib_free(autoPara->limitRange.maxY);
  if(autoPara->limitRange.minB)
    calib_free(autoPara->limitRange.minB);
  if(autoPara->limitRange.minR)
    calib_free(autoPara->limitRange.minR);
  if(autoPara->limitRange.minG)
    calib_free(autoPara->limitRange.minG);
  if(autoPara->limitRange.minY)
    calib_free(autoPara->limitRange.minY);
  CalibDbV2_Wb_Awb_Ext_Com_Para_t* autoExtPara = &awb->autoExtPara;
  if (autoExtPara->lightSourceForFirstFrame)
      calib_free(autoExtPara->lightSourceForFirstFrame);
  CalibDbV2_Awb_Tolerance_t* tolerance = &autoExtPara->tolerance;
  if (tolerance->lumaValue)
      calib_free(tolerance->lumaValue);
  if (tolerance->toleranceValue)
      calib_free(tolerance->toleranceValue);

  CalibDbV2_Awb_runinterval_t* runInterval = &autoExtPara->runInterval;
  if (runInterval->lumaValue)
      calib_free(runInterval->lumaValue);
  if (runInterval->intervalValue)
      calib_free(runInterval->intervalValue);

  CalibDbV2_Awb_GainAdjust_t* wbGainAdjust = &autoExtPara->wbGainAdjust;
  if (wbGainAdjust->lutAll) {
      for (int i = 0; i < wbGainAdjust->lutAll_len; i++) {
        CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t *lutAll = wbGainAdjust->lutAll + i;
        if (lutAll->ct_lut_out)
            calib_free(lutAll->ct_lut_out);
        if (lutAll->cri_lut_out)
            calib_free(lutAll->cri_lut_out);
      }
      calib_free(wbGainAdjust->lutAll);
  }

  CalibDbV2_Awb_Cct_Clip_Cfg_t* wbGainClip = &autoExtPara->wbGainClip;
  if (wbGainClip->cct)
      calib_free(wbGainClip->cct);
  if (wbGainClip->cri_bound_up)
      calib_free(wbGainClip->cri_bound_up);
  if (wbGainClip->cri_bound_low)
      calib_free(wbGainClip->cri_bound_low);

  if (autoExtPara->weightForNightGainCalc)
      calib_free(autoExtPara->weightForNightGainCalc);

  CalibDbV2_Awb_Sgc_t* singleColorProces = &autoExtPara->singleColorProces;
  if (singleColorProces->colorBlock)
      calib_free(singleColorProces->colorBlock);
  if (singleColorProces->lsUsedForEstimation) {
      for (int i = 0; i < singleColorProces->lsUsedForEstimation_len; i++) {
          CalibDbV2_Awb_Sgc_Ls_t *lsUsedForEstimation = singleColorProces->lsUsedForEstimation + i;
          calib_free(lsUsedForEstimation->name);
      }
      calib_free(singleColorProces->lsUsedForEstimation);
  }
  if(autoExtPara->division.wpNumTh.high)
    calib_free(autoExtPara->division.wpNumTh.high);
  if(autoExtPara->division.wpNumTh.low)
    calib_free(autoExtPara->division.wpNumTh.low);
  if(autoExtPara->division.wpNumTh.lumaValue)
    calib_free(autoExtPara->division.wpNumTh.lumaValue);
  if(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue)
    calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue);
  if(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType)
    calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType);
  if(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType)
    calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType);
  return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeGammaCtx(CalibDbV2_gamma_t* gamma)
{
  return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeBlcCtx(CalibDbV2_Ablc_t* blc)
{
    AblcParaV2_t* BlcTuningPara = &blc->BlcTuningPara;
    Blc_data_t* BLC_Data = &BlcTuningPara->BLC_Data;
    if (BLC_Data->ISO)
      calib_free(BLC_Data->ISO);
    if (BLC_Data->R_Channel)
      calib_free(BLC_Data->R_Channel);
    if (BLC_Data->Gr_Channel)
      calib_free(BLC_Data->Gr_Channel);
    if (BLC_Data->Gb_Channel)
      calib_free(BLC_Data->Gb_Channel);
    if (BLC_Data->B_Channel)
      calib_free(BLC_Data->B_Channel);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeGicV21Ctx(CalibDbV2_Gic_V21_t* gic)
{
    CalibDbGicV21_t* GicTuningPara = &gic->GicTuningPara;
    Gic_setting_v21_t* GicData = &GicTuningPara->GicData;
    if (GicData->ISO)
      calib_free(GicData->ISO);
    if (GicData->min_busy_thre)
      calib_free(GicData->min_busy_thre);
    if (GicData->min_grad_thr1)
      calib_free(GicData->min_grad_thr1);
    if (GicData->min_grad_thr2)
      calib_free(GicData->min_grad_thr2);
    if (GicData->k_grad1)
      calib_free(GicData->k_grad1);
    if (GicData->k_grad2)
      calib_free(GicData->k_grad2);
    if (GicData->gb_thre)
      calib_free(GicData->gb_thre);
    if (GicData->maxCorV)
      calib_free(GicData->maxCorV);
    if (GicData->maxCorVboth)
      calib_free(GicData->maxCorVboth);
    if (GicData->dark_thre)
      calib_free(GicData->dark_thre);
    if (GicData->dark_threHi)
      calib_free(GicData->dark_threHi);
    if (GicData->k_grad1_dark)
      calib_free(GicData->k_grad1_dark);
    if (GicData->k_grad2_dark)
      calib_free(GicData->k_grad2_dark);
    if (GicData->min_grad_thr_dark1)
      calib_free(GicData->min_grad_thr_dark1);
    if (GicData->min_grad_thr_dark2)
      calib_free(GicData->min_grad_thr_dark2);
    if (GicData->noiseCurve_0)
      calib_free(GicData->noiseCurve_0);
    if (GicData->noiseCurve_1)
      calib_free(GicData->noiseCurve_1);
    if (GicData->NoiseScale)
      calib_free(GicData->NoiseScale);
    if (GicData->NoiseBase)
      calib_free(GicData->NoiseBase);
    if (GicData->globalStrength)
      calib_free(GicData->globalStrength);
    if (GicData->diff_clip)
      calib_free(GicData->diff_clip);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeDehazeV21Ctx(CalibDbV2_dehaze_V21_t* dehaze)
{
    CalibDbDehazeV21_t* DehazeTuningPara = &dehaze->DehazeTuningPara;

    Dehaze_Setting_V21_t* dehaze_setting = &DehazeTuningPara->dehaze_setting;
    DehazeDataV21_t* DehazeData = &dehaze_setting->DehazeData;

    if (DehazeData->EnvLv)
      calib_free(DehazeData->EnvLv);
    if (DehazeData->dc_min_th)
      calib_free(DehazeData->dc_min_th);
    if (DehazeData->dc_max_th)
      calib_free(DehazeData->dc_max_th);
    if (DehazeData->yhist_th)
      calib_free(DehazeData->yhist_th);
    if (DehazeData->yblk_th)
      calib_free(DehazeData->yblk_th);
    if (DehazeData->dark_th)
      calib_free(DehazeData->dark_th);
    if (DehazeData->bright_min)
      calib_free(DehazeData->bright_min);
    if (DehazeData->bright_max)
      calib_free(DehazeData->bright_max);
    if (DehazeData->wt_max)
      calib_free(DehazeData->wt_max);
    if (DehazeData->air_min)
      calib_free(DehazeData->air_min);
    if (DehazeData->air_max)
      calib_free(DehazeData->air_max);
    if (DehazeData->tmax_base)
      calib_free(DehazeData->tmax_base);
    if (DehazeData->tmax_off)
      calib_free(DehazeData->tmax_off);
    if (DehazeData->tmax_max)
      calib_free(DehazeData->tmax_max);
    if (DehazeData->cfg_wt)
      calib_free(DehazeData->cfg_wt);
    if (DehazeData->cfg_air)
      calib_free(DehazeData->cfg_air);
    if (DehazeData->cfg_tmax)
      calib_free(DehazeData->cfg_tmax);
    if (DehazeData->dc_weitcur)
      calib_free(DehazeData->dc_weitcur);
    if (DehazeData->bf_weight)
      calib_free(DehazeData->bf_weight);
    if (DehazeData->range_sigma)
      calib_free(DehazeData->range_sigma);
    if (DehazeData->space_sigma_pre)
      calib_free(DehazeData->space_sigma_pre);
    if (DehazeData->space_sigma_cur)
      calib_free(DehazeData->space_sigma_cur);

    Enhance_Setting_V21_t* enhance_setting = &DehazeTuningPara->enhance_setting;
    EnhanceDataV21_t* EnhanceData = &enhance_setting->EnhanceData;

    if (EnhanceData->EnvLv)
      calib_free(EnhanceData->EnvLv);
    if (EnhanceData->enhance_value)
      calib_free(EnhanceData->enhance_value);
    if (EnhanceData->enhance_chroma)
      calib_free(EnhanceData->enhance_chroma);

    Hist_setting_V21_t* hist_setting = &DehazeTuningPara->hist_setting;
    HistDataV21_t* HistData = &hist_setting->HistData;
    if (HistData->EnvLv)
      calib_free(HistData->EnvLv);
    if (HistData->hist_gratio)
      calib_free(HistData->hist_gratio);
    if (HistData->hist_th_off)
      calib_free(HistData->hist_th_off);
    if (HistData->hist_k)
      calib_free(HistData->hist_k);
    if (HistData->hist_min)
      calib_free(HistData->hist_min);
    if (HistData->hist_scale)
      calib_free(HistData->hist_scale);
    if (HistData->cfg_gratio)
      calib_free(HistData->cfg_gratio);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeDpccCtx(CalibDbV2_Dpcc_t* dpcc)
{
    CalibDbDpccV20_t* DpccTuningPara = &dpcc->DpccTuningPara;
    CalibDb_Dpcc_Fast_Mode_V20_t* Fast_Mode = &DpccTuningPara->Fast_Mode;
    FastData_t* Fast_Data = &Fast_Mode->Fast_Data;

    if (Fast_Data->ISO)
      calib_free(Fast_Data->ISO);
    if (Fast_Data->Single_level)
      calib_free(Fast_Data->Single_level);
    if (Fast_Data->Double_level)
      calib_free(Fast_Data->Double_level);
    if (Fast_Data->Triple_level)
      calib_free(Fast_Data->Triple_level);

    CalibDb_Dpcc_Sensor_V20_t* Sensor_dpcc = &DpccTuningPara->Sensor_dpcc;
    SensorDpccData_t* SensorDpcc_Data = &Sensor_dpcc->SensorDpcc_Data;
    if (SensorDpcc_Data->ISO)
      calib_free(SensorDpcc_Data->ISO);
    if (SensorDpcc_Data->level_single)
      calib_free(SensorDpcc_Data->level_single);
    if (SensorDpcc_Data->level_multiple)
      calib_free(SensorDpcc_Data->level_multiple);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeMergeCtx(CalibDbV2_merge_t* merge)
{
    MergeV20_t* MergeTuningPara = &merge->MergeTuningPara;
    MergeOECurveV20_t* OECurve = &MergeTuningPara->OECurve;
    if (OECurve->EnvLv)
      calib_free(OECurve->EnvLv);
    if (OECurve->Smooth)
      calib_free(OECurve->Smooth);
    if (OECurve->Offset)
      calib_free(OECurve->Offset);

    MergeMDCurveV20_t* MDCurve = &MergeTuningPara->MDCurve;
    if (MDCurve->MoveCoef)
      calib_free(MDCurve->MoveCoef);
    if (MDCurve->LM_smooth)
      calib_free(MDCurve->LM_smooth);
    if (MDCurve->LM_offset)
      calib_free(MDCurve->LM_offset);
    if (MDCurve->MS_smooth)
      calib_free(MDCurve->MS_smooth);
    if (MDCurve->MS_offset)
      calib_free(MDCurve->MS_offset);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeDrcCtx(CalibDbV2_drc_t* drc)
{
    CalibDbV2_Adrc_t* DrcTuningPara = &drc->DrcTuningPara;
    AdrcGain_t* DrcGain = &DrcTuningPara->DrcGain;
    if (DrcGain->EnvLv)
      calib_free(DrcGain->EnvLv);
    if (DrcGain->DrcGain)
      calib_free(DrcGain->DrcGain);
    if (DrcGain->Alpha)
      calib_free(DrcGain->Alpha);
    if (DrcGain->Clip)
      calib_free(DrcGain->Clip);

    HighLight_t* HiLight = &DrcTuningPara->HiLight;
    if (HiLight->EnvLv)
      calib_free(HiLight->EnvLv);
    if (HiLight->Strength)
      calib_free(HiLight->Strength);

    local_t* LocalTMOSetting = &DrcTuningPara->LocalTMOSetting;
    LocalData_t* LocalTMOData = &LocalTMOSetting->LocalTMOData;
    if (LocalTMOData->EnvLv)
      calib_free(LocalTMOData->EnvLv);
    if (LocalTMOData->LocalWeit)
      calib_free(LocalTMOData->LocalWeit);
    if (LocalTMOData->GlobalContrast)
      calib_free(LocalTMOData->GlobalContrast);
    if (LocalTMOData->LoLitContrast)
      calib_free(LocalTMOData->LoLitContrast);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeCpslCtx(CalibDbV2_Cpsl_t* cpsl)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeOrbCtx(CalibDbV2_Orb_t* orb)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeDebayerCtx(CalibDbV2_Debayer_t* edgefilter_v1)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeCprocCtx(CalibDbV2_Cproc_t* cproc)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeIeCtx(CalibDbV2_IE_t* ie)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeLscCtx(CalibDbV2_LSC_t* lsc)
{
    CalibDbV2_Lsc_Common_t* common = &lsc->common;
    if (common->resolutionAll)
        calib_free(common->resolutionAll);

    CalibDbV2_AlscCof_t* alscCoef = &lsc->alscCoef;
    if (alscCoef->illAll) {
        for (int i = 0; i < alscCoef->illAll_len; i++) {
            CalibDbV2_AlscCof_ill_t* ill = alscCoef->illAll + i;
            if (ill->tableUsed)
                calib_free(ill->tableUsed);
            if (ill->gains)
                calib_free(ill->gains);
            if (ill->vig)
                calib_free(ill->vig);
        }
        calib_free(alscCoef->illAll);
    }

    CalibDbV2_LscTable_t* tbl = &lsc->tbl;
    if (tbl->tableAll)
        calib_free(tbl->tableAll);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeColorAsGreyCtx(CalibDbV2_ColorAsGrey_t* colorAsGrey)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeLumaDetectCtx(CalibDbV2_LUMA_DETECT_t* lumaDetect)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeLdchCtx(CalibDbV2_LDCH_t* ldch)
{
    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeCcmCtx(CalibDbV2_Ccm_Para_V2_t* ccm)
{
    CalibDbV2_Ccm_Tuning_Para_t* TuningPara = &ccm->TuningPara;
    CalibDbV2_Ccm_illu_estim_Para_t* illu_estim = &TuningPara->illu_estim;

    if (illu_estim->default_illu)
        calib_free(illu_estim->default_illu);

    if (TuningPara->aCcmCof) {
        for (int i = 0; i < TuningPara->aCcmCof_len; i++) {
            CalibDbV2_Ccm_Accm_Cof_Para_t* aCcmCof = TuningPara->aCcmCof + i;
            if (aCcmCof->name)
                calib_free(aCcmCof->name);
            for ( int j = 0; j < aCcmCof->matrixUsed_len; j++) {
                if (aCcmCof->matrixUsed[j])
                    calib_free(aCcmCof->matrixUsed[j]);
            }
            if (aCcmCof->matrixUsed)
                calib_free(aCcmCof->matrixUsed);
        }
        calib_free(TuningPara->aCcmCof);
    }

    if (TuningPara->matrixAll) {
        for (int i = 0; i < TuningPara->matrixAll_len; i++) {
            CalibDbV2_Ccm_Ccm_Matrix_Para_t* matrixAll = TuningPara->matrixAll + i;
            if (matrixAll->name)
                calib_free(matrixAll->name);
            if (matrixAll->illumination)
                calib_free(matrixAll->illumination);
        }
        calib_free(TuningPara->matrixAll);
    }

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeLut3dCtx(CalibDbV2_Lut3D_Para_V2_t* lut3d)
{
    CalibDbV2_Lut3D_Auto_Para_t* ALut3D = &lut3d->ALut3D;
    if (ALut3D->lutAll) {
        CalibDbV2_Lut3D_LutPara_t* lutAll = ALut3D->lutAll;
        for (int i = 0; i < ALut3D->lutAll_len; i++) {
            lutAll = lutAll + i;
            if (lutAll->name)
                calib_free(lutAll->name);
        }

        calib_free(ALut3D->lutAll);
    }

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeAfCtx(CalibDbV2_AF_t* af)
{
    CalibDbV2_AF_Tuning_Para_t* TuningPara = &af->TuningPara;
    CalibDbV2_Af_ZoomFocusTbl_t* zoomfocus_tbl = &TuningPara->zoomfocus_tbl;
    if (zoomfocus_tbl->focal_length)
        calib_free(zoomfocus_tbl->focal_length);
    if (zoomfocus_tbl->zoom_pos)
        calib_free(zoomfocus_tbl->zoom_pos);
    if (zoomfocus_tbl->focus_infpos)
        calib_free(zoomfocus_tbl->focus_infpos);
    if (zoomfocus_tbl->focus_macropos)
        calib_free(zoomfocus_tbl->focus_macropos);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeThumbnailsCtx(CalibDbV2_Thumbnails_t* thumbnails)
{
    CalibDbV2_Thumbnails_Param_t* param = &thumbnails->param;
    if (param->thumbnail_configs)
        calib_free(param->thumbnail_configs);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeBayerNrV2Ctx(CalibDbV2_BayerNrV2_t* bayernr_v1)
{
    if (bayernr_v1->Version)
        calib_free(bayernr_v1->Version);

    CalibDbV2_BayerNrV2_CalibPara_t* CalibPara = &bayernr_v1->CalibPara;
    for (int i = 0; i < CalibPara->Setting_len; i++) {
        CalibDbV2_BayerNrV2_CalibPara_Setting_t *Setting = CalibPara->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Calib_ISO)
            calib_free(Setting->Calib_ISO);
    }
    if (CalibPara->Setting)
        calib_free(CalibPara->Setting);

    CalibDbV2_BayerNrV2_Bayernr2d_t* Bayernr2D = &bayernr_v1->Bayernr2D;
    for (int i = 0; i < CalibPara->Setting_len; i++) {
        CalibDbV2_BayerNrV2_Bayernr2d_Setting_t *Setting = Bayernr2D->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Tuning_ISO)
            calib_free(Setting->Tuning_ISO);
    }
    if (Bayernr2D->Setting)
        calib_free(Bayernr2D->Setting);

    CalibDbV2_BayerNrV2_Bayernr3d_t * Bayernr3D = &bayernr_v1->Bayernr3D;
    for (int i = 0; i < CalibPara->Setting_len; i++) {
        CalibDbV2_BayerNrV2_Bayernr3d_Setting_t *Setting = Bayernr3D->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Tuning_ISO)
            calib_free(Setting->Tuning_ISO);
    }
    if (Bayernr3D->Setting)
        calib_free(Bayernr3D->Setting);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeCnrCtx(CalibDbV2_CNR_t* cnr)
{
    if (cnr->Version)
        calib_free(cnr->Version);

    CalibDbV2_CNR_TuningPara_t* TuningPara = &cnr->TuningPara;
    for (int i = 0; i < TuningPara->Setting_len; i++) {
        CalibDbV2_CNR_TuningPara_Setting_t *Setting = TuningPara->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Tuning_ISO)
            calib_free(Setting->Tuning_ISO);
    }
    if (TuningPara->Setting)
        calib_free(TuningPara->Setting);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeYnrV2Ctx(CalibDbV2_YnrV2_t* ynr_v2)
{
    if (ynr_v2->Version)
        calib_free(ynr_v2->Version);

    CalibDbV2_YnrV2_CalibPara_t* CalibPara = &ynr_v2->CalibPara;
    for (int i = 0; i < CalibPara->Setting_len; i++) {
        CalibDbV2_YnrV2_CalibPara_Setting_t *Setting = CalibPara->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Calib_ISO)
            calib_free(Setting->Calib_ISO);
    }
    if (CalibPara->Setting)
        calib_free(CalibPara->Setting);

    CalibDbV2_YnrV2_TuningPara_t* TuningPara = &ynr_v2->TuningPara;
    for (int i = 0; i < TuningPara->Setting_len; i++) {
        CalibDbV2_YnrV2_TuningPara_Setting_t *Setting = TuningPara->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Tuning_ISO)
            calib_free(Setting->Tuning_ISO);
    }
    if (TuningPara->Setting)
        calib_free(TuningPara->Setting);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeSharpV3Ctx(CalibDbV2_SharpV3_t* sharp_v3)
{
    if (sharp_v3->Version)
        calib_free(sharp_v3->Version);

    CalibDbV2_SharpV3_TuningPara_t* TuningPara = &sharp_v3->TuningPara;
    for (int i = 0; i < TuningPara->Setting_len; i++) {
        CalibDbV2_SharpV3_TuningPara_Setting_t *Setting = TuningPara->Setting + i;

        if (Setting->SNR_Mode)
            calib_free(Setting->SNR_Mode);
        if (Setting->Sensor_Mode)
            calib_free(Setting->Sensor_Mode);
        if (Setting->Tuning_ISO)
            calib_free(Setting->Tuning_ISO);
    }
    if (TuningPara->Setting)
        calib_free(TuningPara->Setting);

    return 0;
}

int RkAiqCalibDbV2::CamCalibDbFreeSceneCtx(void* scene_ctx) {
    CamCalibDbV2Context_t ctx_temp;
    ctx_temp.calib_scene = (char*)scene_ctx;

    CamCalibDbV2Context_t* ctx = &ctx_temp;

    if(CHECK_ISP_HW_V21()) {
        CalibDbV2_Ccm_Para_V2_t *ccm_calib =
            (CalibDbV2_Ccm_Para_V2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ccm_calib));
        CamCalibDbFreeCcmCtx(ccm_calib);

#if 0 // TODO: move out
        CalibDb_Module_ParaV2_t *module_calib =
            (CalibDb_Module_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, module_calib));
        CamCalibDbFreeModuleCtx(module_calib);
#endif
        CalibDb_Aec_ParaV2_t *ae_calib =
            (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ae_calib));
        CamCalibDbFreeAeCtx(ae_calib);

        CalibDbV2_Wb_Para_V21_t *wb_v21 =
            (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, wb_v21));
        CamCalibDbFreeAwbV21Ctx(wb_v21);

        CalibDbV2_gamma_t *agamma_calib =
            (CalibDbV2_gamma_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, agamma_calib));
        CamCalibDbFreeGammaCtx(agamma_calib);

        CalibDbV2_Ablc_t *ablc_calib =
            (CalibDbV2_Ablc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ablc_calib));
        CamCalibDbFreeBlcCtx(ablc_calib);

        CalibDbV2_Gic_V21_t *agic_calib_v21 =
            (CalibDbV2_Gic_V21_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, agic_calib_v21));
        CamCalibDbFreeGicV21Ctx(agic_calib_v21);

        CalibDbV2_dehaze_V21_t *adehaze_calib_v21 =
            (CalibDbV2_dehaze_V21_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, adehaze_calib_v21));
        CamCalibDbFreeDehazeV21Ctx(adehaze_calib_v21);

        CalibDbV2_Dpcc_t *adpcc_calib =
            (CalibDbV2_Dpcc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, adpcc_calib));
        CamCalibDbFreeDpccCtx(adpcc_calib);

        CalibDbV2_merge_t *amerge_calib =
            (CalibDbV2_merge_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, amerge_calib));
        CamCalibDbFreeMergeCtx(amerge_calib);

        CalibDbV2_drc_t *adrc_calib =
            (CalibDbV2_drc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, adrc_calib));
        CamCalibDbFreeDrcCtx(adrc_calib);

        CalibDbV2_Cpsl_t *cpsl =
            (CalibDbV2_Cpsl_t *)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cpsl));
        CamCalibDbFreeCpslCtx(cpsl);

        CalibDbV2_Orb_t *orb =
            (CalibDbV2_Orb_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, orb));
        CamCalibDbFreeOrbCtx(orb);

        CalibDbV2_Debayer_t *debayer =
            (CalibDbV2_Debayer_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, debayer));
        CamCalibDbFreeDebayerCtx(debayer);

        CalibDbV2_Cproc_t *cproc =
            (CalibDbV2_Cproc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cproc));
        CamCalibDbFreeCprocCtx(cproc);

        CalibDbV2_IE_t *ie =
            (CalibDbV2_IE_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ie));
        CamCalibDbFreeIeCtx(ie);

        CalibDbV2_LSC_t *lsc_v2 =
            (CalibDbV2_LSC_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lsc_v2));
        CamCalibDbFreeLscCtx(lsc_v2);

        CalibDbV2_ColorAsGrey_t *colorAsGrey =
            (CalibDbV2_ColorAsGrey_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, colorAsGrey));
        CamCalibDbFreeColorAsGreyCtx(colorAsGrey);

        CalibDbV2_LUMA_DETECT_t *lumaDetect =
            (CalibDbV2_LUMA_DETECT_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lumaDetect));
        CamCalibDbFreeLumaDetectCtx(lumaDetect);

        CalibDbV2_LDCH_t *aldch =
            (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, aldch));
        CamCalibDbFreeLdchCtx(aldch);

        CalibDbV2_Lut3D_Para_V2_t *lut3d_calib =
            (CalibDbV2_Lut3D_Para_V2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lut3d_calib));
        CamCalibDbFreeLut3dCtx(lut3d_calib);

        CalibDbV2_AF_t *af =
            (CalibDbV2_AF_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, af));
        CamCalibDbFreeAfCtx(af);

        CalibDbV2_Thumbnails_t *thumbnails =
            (CalibDbV2_Thumbnails_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, thumbnails));
        CamCalibDbFreeThumbnailsCtx(thumbnails);

        CalibDbV2_BayerNrV2_t *bayernr_v2 =
            (CalibDbV2_BayerNrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayernr_v2));
        CamCalibDbFreeBayerNrV2Ctx(bayernr_v2);

        CalibDbV2_CNR_t *cnr_v1 =
            (CalibDbV2_CNR_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cnr_v1));
        CamCalibDbFreeCnrCtx(cnr_v1);

        CalibDbV2_YnrV2_t *ynr_v2 =
            (CalibDbV2_YnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ynr_v2));
        CamCalibDbFreeYnrV2Ctx(ynr_v2);

        CalibDbV2_SharpV3_t *sharp_v3 =
            (CalibDbV2_SharpV3_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, sharp_v3));
        CamCalibDbFreeSharpV3Ctx(sharp_v3);
    } else if(CHECK_ISP_HW_V20()) {
        // TODO: implement ispv20 calib free
    } else {
        XCAM_LOG_ERROR("%s unsupported isp plateform !", __func__);
    }
    return 0;
}

} // namespace RkCam