#include "iniparser.h"
#include "param.h"
#include "uvc_log.h"
#include <rk_aiq_user_api2_acsm.h>
#include <rk_aiq_user_api2_camgroup.h>
#include <rk_aiq_user_api2_imgproc.h>
#include <rk_aiq_user_api2_sysctl.h>

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "isp.c"

#define MAX_AIQ_CTX 8
char g_iq_file_dir_[256];

static int rkuvc_aiq_use_group = 0;
static rk_aiq_sys_ctx_t *g_aiq_ctx[MAX_AIQ_CTX];
static rk_aiq_camgroup_ctx_t *g_camera_group_ctx[MAX_AIQ_CTX];
rk_aiq_working_mode_t g_WDRMode[MAX_AIQ_CTX];
rk_aiq_wb_gain_t gs_wb_gain = {2.083900, 1.000000, 1.000000, 2.018500};

#define RK_ISP_CHECK_CAMERA_ID(CAMERA_ID)                                      \
  do {                                                                         \
    if (rkuvc_aiq_use_group) {                                                 \
      if (CAMERA_ID >= MAX_AIQ_CTX || !g_camera_group_ctx[CAMERA_ID]) {        \
        LOG_ERROR("camera_group_id is over 3 or not init\n");                  \
        return -1;                                                             \
      }                                                                        \
    } else {                                                                   \
      if (CAMERA_ID >= MAX_AIQ_CTX || !g_aiq_ctx[CAMERA_ID]) {                 \
        LOG_ERROR("camera_id is over 3 or not init\n");                        \
        return -1;                                                             \
      }                                                                        \
    }                                                                          \
  } while (0)

#define RK_ISP_CHECK_NORMAL_MODE(CAMERA_ID)                                    \
  do {                                                                         \
    if (g_WDRMode[cam_id] != RK_AIQ_WORKING_MODE_NORMAL) {                     \
      LOG_ERROR("Not support in HDR mode\n");                                  \
      return 0;                                                                \
    }                                                                          \
  } while (0)

rk_aiq_sys_ctx_t *rkuvc_aiq_get_ctx(int cam_id) {
  if (rkuvc_aiq_use_group)
    return (rk_aiq_sys_ctx_t *)g_camera_group_ctx[cam_id];

  return g_aiq_ctx[cam_id];
}

int sample_common_isp_init(int cam_id, rk_aiq_working_mode_t WDRMode,
                           bool MultiCam, const char *iq_file_dir) {
  if (cam_id >= MAX_AIQ_CTX) {
    LOG_ERROR("%s : cam_id is over 3\n", __FUNCTION__);
    return -1;
  }
  setlinebuf(stdout);
  if (iq_file_dir == NULL) {
    LOG_ERROR("rk_isp_init : not start.\n");
    g_aiq_ctx[cam_id] = NULL;
    return 0;
  }

  // must set HDR_MODE, before init
  g_WDRMode[cam_id] = WDRMode;
  char hdr_str[16];
  snprintf(hdr_str, sizeof(hdr_str), "%d", (int)WDRMode);
  setenv("HDR_MODE", hdr_str, 1);

  rk_aiq_sys_ctx_t *aiq_ctx;
  rk_aiq_static_info_t aiq_static_info;
  rk_aiq_uapi2_sysctl_enumStaticMetas(cam_id, &aiq_static_info);
  if (aiq_static_info.sensor_info.phyId == -1) {
    LOG_INFO("WARN: aiq_static_info.sensor_info.phyId is %d\n",
             aiq_static_info.sensor_info.phyId);
  }

  LOG_INFO("ID: %d, sensor_name is %s, iqfiles is %s\n", cam_id,
           aiq_static_info.sensor_info.sensor_name, iq_file_dir);

  int ret;
  if (WDRMode == RK_AIQ_WORKING_MODE_NORMAL)
    ret = rk_aiq_uapi2_sysctl_preInit_scene(
        aiq_static_info.sensor_info.sensor_name, "normal", "day");
  else
    ret = rk_aiq_uapi2_sysctl_preInit_scene(
        aiq_static_info.sensor_info.sensor_name, "hdr", "day");
  if (ret < 0)
    LOG_ERROR("%s: failed to set scene\n",
              aiq_static_info.sensor_info.sensor_name);

#if 1
  aiq_ctx = rk_aiq_uapi2_sysctl_init(aiq_static_info.sensor_info.sensor_name,
                                     iq_file_dir, NULL, NULL);
// LOG_ERROR("tmp force use m00_b_imx464 3-001a\n");
#else
  if (cam_id == 0)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m02_b_imx464 3-001a", iq_file_dir, NULL,
                                       NULL);
  else if (cam_id == 1)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m03_b_imx464 3-0036", iq_file_dir, NULL,
                                       NULL);
  else if (cam_id == 2)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m00_b_imx464 4-001a", iq_file_dir, NULL,
                                       NULL);
  else if (cam_id == 3)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m01_b_imx464 4-0036", iq_file_dir, NULL,
                                       NULL);
  else if (cam_id == 4)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m04_b_imx464 5-001a", iq_file_dir, NULL,
                                       NULL);
  else if (cam_id == 5)
    aiq_ctx = rk_aiq_uapi2_sysctl_init("m05_b_imx464 5-0036", iq_file_dir, NULL,
                                       NULL);
#endif
  // if (MultiCam)
  // 	rk_aiq_uapi2_sysctl_setMulCamConc(aiq_ctx, true);

  g_aiq_ctx[cam_id] = aiq_ctx;

  return 0;
}

int sample_common_isp_run(int cam_id) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  if (rk_aiq_uapi2_sysctl_prepare(g_aiq_ctx[cam_id], 0, 0, g_WDRMode[cam_id])) {
    LOG_ERROR("rkaiq engine prepare failed !\n");
    g_aiq_ctx[cam_id] = NULL;
    return -1;
  }
  LOG_INFO("cam_id:%d,rk_aiq_uapi2_sysctl_init/prepare succeed\n", cam_id);
  if (rk_aiq_uapi2_sysctl_start(g_aiq_ctx[cam_id])) {
    LOG_ERROR("cam_id:%d,rk_aiq_uapi2_sysctl_start  failed\n", cam_id);
    return -1;
  }
  LOG_INFO("cam_id:%d,rk_aiq_uapi2_sysctl_start succeed\n", cam_id);
  return 0;
}

int isp_camera_group_init(int cam_group_id, rk_aiq_working_mode_t WDRMode,
                          bool MultiCam, const char *iq_file_dir) {
  int ret;
  rk_aiq_sys_ctx_t *aiq_ctx;
  rk_aiq_static_info_t aiq_static_info;
  char sensor_name_array[6][128];
  rk_aiq_camgroup_instance_cfg_t camgroup_cfg;
  memset(&camgroup_cfg, 0, sizeof(camgroup_cfg));

  camgroup_cfg.sns_num = rk_param_get_int("avs:sensor_num", 6);
  LOG_INFO("camgroup_cfg.sns_num is %d\n", camgroup_cfg.sns_num);
  for (int i = 0; i < camgroup_cfg.sns_num; i++) {
    rk_aiq_uapi2_sysctl_enumStaticMetas(i, &aiq_static_info);
    LOG_INFO("cam_group_id:%d, cam_id: %d, sensor_name is %s, iqfiles is %s\n",
             cam_group_id, i, aiq_static_info.sensor_info.sensor_name,
             iq_file_dir);
    memcpy(sensor_name_array[i], aiq_static_info.sensor_info.sensor_name,
           strlen(aiq_static_info.sensor_info.sensor_name) + 1);
    camgroup_cfg.sns_ent_nm_array[i] = sensor_name_array[i];
    LOG_INFO("camgroup_cfg.sns_ent_nm_array[%d] is %s\n", i,
             camgroup_cfg.sns_ent_nm_array[i]);
    if (WDRMode == RK_AIQ_WORKING_MODE_NORMAL)
      ret = rk_aiq_uapi2_sysctl_preInit_scene(
          aiq_static_info.sensor_info.sensor_name, "normal", "day");
    else
      ret = rk_aiq_uapi2_sysctl_preInit_scene(
          aiq_static_info.sensor_info.sensor_name, "hdr", "day");
    if (ret < 0)
      LOG_ERROR("%s: failed to set scene\n",
                aiq_static_info.sensor_info.sensor_name);
  }

  camgroup_cfg.config_file_dir = iq_file_dir;
  g_camera_group_ctx[cam_group_id] =
      rk_aiq_uapi2_camgroup_create(&camgroup_cfg);
  if (!g_camera_group_ctx[cam_group_id]) {
    LOG_ERROR("create camgroup ctx error!\n");
    return -1;
  }
  LOG_INFO("rk_aiq_uapi2_camgroup_create over\n");
  ret =
      rk_aiq_uapi2_camgroup_prepare(g_camera_group_ctx[cam_group_id], WDRMode);
  LOG_INFO("rk_aiq_uapi2_camgroup_prepare over\n");
  ret |= rk_aiq_uapi2_camgroup_start(g_camera_group_ctx[cam_group_id]);
  LOG_INFO("rk_aiq_uapi2_camgroup_start over\n");

  return ret;
}

int isp_camera_group_stop(int cam_group_id) {
  RK_ISP_CHECK_CAMERA_ID(cam_group_id);
  LOG_INFO("rk_aiq_uapi2_camgroup_stop enter\n");
  rk_aiq_uapi2_camgroup_stop(g_camera_group_ctx[cam_group_id]);
  LOG_INFO("rk_aiq_uapi2_camgroup_destroy enter\n");
  rk_aiq_uapi2_camgroup_destroy(g_camera_group_ctx[cam_group_id]);
  LOG_INFO("rk_aiq_uapi2_camgroup_destroy exit\n");
  g_camera_group_ctx[cam_group_id] = NULL;

  return 0;
}

int rk_isp_set_frame_rate(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  Uapi_ExpSwAttrV2_t expSwAttr;
  LOG_INFO("start %d\n", value);
  ret = rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &expSwAttr);
  expSwAttr.stAuto.stFrmRate.isFpsFix = true;
  expSwAttr.stAuto.stFrmRate.FpsValue = value;
  ret = rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), expSwAttr);
  LOG_INFO("end, %d\n", value);

  snprintf(entry, 127, "isp.%d.adjustment:fps", cam_id);
  // rk_param_set_int(entry, value);

  return 0;
}

// image adjustment

int rk_isp_get_contrast(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:contrast", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_contrast(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  acp_attrib_t attrib;
  ret = rk_aiq_user_api2_acp_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  attrib.contrast = value * 2.55; // value[0,255]
  ret |= rk_aiq_user_api2_acp_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  snprintf(entry, 127, "isp.%d.adjustment:contrast", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_brightness(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:brightness", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_brightness(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  acp_attrib_t attrib;
  ret = rk_aiq_user_api2_acp_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  attrib.brightness = value * 2.55; // value[0,255]
  ret |= rk_aiq_user_api2_acp_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  snprintf(entry, 127, "isp.%d.adjustment:brightness", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_saturation(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:saturation", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_saturation(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  acp_attrib_t attrib;
  ret = rk_aiq_user_api2_acp_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  attrib.saturation = value * 2.55; // value[0,255]
  ret |= rk_aiq_user_api2_acp_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  snprintf(entry, 127, "isp.%d.adjustment:saturation", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_sharpness(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:sharpness", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_sharpness(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  ret = rk_aiq_uapi2_setSharpness(rkuvc_aiq_get_ctx(cam_id), value);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:sharpness", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_hue(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:hue", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_hue(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  acp_attrib_t attrib;
  ret = rk_aiq_user_api2_acp_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  attrib.hue = value * 2.55; // value[0,255]
  ret |= rk_aiq_user_api2_acp_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  snprintf(entry, 127, "isp.%d.adjustment:hue", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_hue_mode(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.adjustment:hueauto", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_hue_mode(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  if (value == 1)
    value = 50; // auto
  else {
    rk_isp_get_hue(cam_id, &value);
    if (value == -1)
      value = 50;
  }
  LOG_INFO("hue_mode: value: %d\n", value);
  int ret;
  char entry[128] = {'\0'};
  acp_attrib_t attrib;
  ret = rk_aiq_user_api2_acp_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  attrib.hue = value * 2.55; // value[0,255]
  ret |= rk_aiq_user_api2_acp_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attrib);
  snprintf(entry, 127, "isp.%d.adjustment:hueauto", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

// exposure
int rk_isp_get_exposure_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_mode", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_exposure_mode(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  Uapi_ExpSwAttrV2_t expSwAttr;
  rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &expSwAttr);
  if (!strcmp(value, "auto")) {
    expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
  } else {
    if (g_WDRMode[cam_id] != RK_AIQ_WORKING_MODE_NORMAL) {
      expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
      expSwAttr.stManual.HdrAE.ManualGainEn = true;
      expSwAttr.stManual.HdrAE.ManualTimeEn = true;
    } else {
      expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
      expSwAttr.stManual.LinearAE.ManualGainEn = true;
      expSwAttr.stManual.LinearAE.ManualTimeEn = true;
    }
  }
  int ret =
      rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), expSwAttr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_mode", cam_id);
  rk_param_set_string(entry, value);

  return 0;
}

int rk_isp_get_gain_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:gain_mode", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_gain_mode(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  Uapi_ExpSwAttrV2_t stExpSwAttr;

  rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &stExpSwAttr);
  if (!strcmp(value, "auto")) {
    stExpSwAttr.stManual.LinearAE.ManualGainEn = false;
    stExpSwAttr.stManual.HdrAE.ManualGainEn = false;
  } else {
    stExpSwAttr.stManual.LinearAE.ManualGainEn = true;
    stExpSwAttr.stManual.HdrAE.ManualGainEn = true;
  }
  int ret =
      rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), stExpSwAttr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:gain_mode", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_exposure_time(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_time", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_exposure_time(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  Uapi_ExpSwAttrV2_t stExpSwAttr;
  float den, num, result;
  if (strchr(value, '/') == NULL) {
    den = 1;
    sscanf(value, "%f", &result);
  } else {
    sscanf(value, "%f/%f", &num, &den);
    result = num / den;
  }
  rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &stExpSwAttr);
  stExpSwAttr.stManual.LinearAE.TimeValue = result;
  stExpSwAttr.stManual.HdrAE.TimeValue[0] = result;
  stExpSwAttr.stManual.HdrAE.TimeValue[1] = result;
  stExpSwAttr.stManual.HdrAE.TimeValue[2] = result;
  int ret =
      rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), stExpSwAttr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_time", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_exposure_gain(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_gain", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_exposure_gain(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  Uapi_ExpSwAttrV2_t stExpSwAttr;
  float gain_set = (value * 1.0f);
  rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &stExpSwAttr);
  stExpSwAttr.stManual.LinearAE.GainValue = gain_set;
  stExpSwAttr.stManual.HdrAE.GainValue[0] = gain_set;
  stExpSwAttr.stManual.HdrAE.GainValue[1] = gain_set;
  stExpSwAttr.stManual.HdrAE.GainValue[2] = gain_set;
  int ret =
      rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), stExpSwAttr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.exposure:exposure_gain", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

// blc
int rk_isp_get_hdr(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_hdr(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_blc_region(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:blc_region", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_blc_region(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  RK_ISP_CHECK_NORMAL_MODE(cam_id);
  Uapi_LinExpAttrV2_t LineExpAttr;

  ret = rk_aiq_user_api2_ae_getLinExpAttr(rkuvc_aiq_get_ctx(cam_id),
                                          &LineExpAttr);
  if (!strcmp(value, "close"))
    LineExpAttr.Params.BackLightCtrl.Enable = 0;
  else
    LineExpAttr.Params.BackLightCtrl.Enable = 1;
  LineExpAttr.Params.BackLightCtrl.MeasArea = AECV2_MEASURE_AREA_AUTO;
  LineExpAttr.Params.BackLightCtrl.StrBias = 0;
  ret =
      rk_aiq_user_api2_ae_setLinExpAttr(rkuvc_aiq_get_ctx(cam_id), LineExpAttr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:blc_region", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_hlc(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hlc", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_hlc(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  RK_ISP_CHECK_NORMAL_MODE(cam_id);
  Uapi_LinExpAttrV2_t LinExpAttr;

  ret =
      rk_aiq_user_api2_ae_getLinExpAttr(rkuvc_aiq_get_ctx(cam_id), &LinExpAttr);
  if (ret)
    LOG_ERROR("get exp attr failed\n");
  if (!strcmp(value, "close"))
    LinExpAttr.Params.OverExpCtrl.Enable = 0;
  else
    LinExpAttr.Params.OverExpCtrl.Enable = 1;
  LinExpAttr.Params.OverExpCtrl.StrBias = 0;
  ret =
      rk_aiq_user_api2_ae_setLinExpAttr(rkuvc_aiq_get_ctx(cam_id), LinExpAttr);
  if (ret)
    LOG_ERROR("set exp attr failed\n");
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hlc", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_hdr_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_hdr_level(int cam_id, int value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  rk_aiq_uapi2_setDrcGain(rkuvc_aiq_get_ctx(cam_id), (float)value, 0.1,
                          16); // Gain: [1, 8]
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_blc_strength(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:blc_strength", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_blc_strength(int cam_id, int value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  RK_ISP_CHECK_NORMAL_MODE(cam_id);
  Uapi_LinExpAttrV2_t LineExpAttr;

  ret = rk_aiq_user_api2_ae_getLinExpAttr(rkuvc_aiq_get_ctx(cam_id),
                                          &LineExpAttr);
  if (ret)
    LOG_ERROR("getLinExpAttr error\n");
  if (LineExpAttr.Params.BackLightCtrl.Enable == 0) {
    LOG_ERROR("blc mode is not enabled\n");
    return 0;
  }
  LineExpAttr.Params.BackLightCtrl.StrBias = value;
  ret =
      rk_aiq_user_api2_ae_setLinExpAttr(rkuvc_aiq_get_ctx(cam_id), LineExpAttr);
  if (ret)
    LOG_ERROR("setLinExpAttr error\n");
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:blc_strength", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_hlc_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hlc_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_hlc_level(int cam_id, int value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  RK_ISP_CHECK_NORMAL_MODE(cam_id);
  Uapi_LinExpAttrV2_t LineExpAttr;

  if (value == 0)
    value = 1;
  ret = rk_aiq_user_api2_ae_getLinExpAttr(rkuvc_aiq_get_ctx(cam_id),
                                          &LineExpAttr);
  if (ret)
    LOG_ERROR("getLinExpAttr error\n");
  if (LineExpAttr.Params.OverExpCtrl.Enable == 0) {
    LOG_ERROR("hlc mode is not enabled\n");
    return 0;
  }
  LineExpAttr.Params.OverExpCtrl.StrBias = value;
  ret =
      rk_aiq_user_api2_ae_setLinExpAttr(rkuvc_aiq_get_ctx(cam_id), LineExpAttr);
  if (ret)
    LOG_ERROR("setLinExpAttr error\n");
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hlc_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_dark_boost_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:dark_boost_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_dark_boost_level(int cam_id, int value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  LOG_ERROR("ISP3.0 do not support tmo api\n");
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:dark_boost_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

// white_blance
int rk_isp_get_white_blance_style(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.white_blance:white_blance_style", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_white_blance_style(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  rk_aiq_uapiV2_wb_opMode_t attr;

  if (!strcmp(value, "manualWhiteBalance")) {
    attr.mode = RK_AIQ_WB_MODE_MANUAL;
  } else {
    attr.mode = RK_AIQ_WB_MODE_AUTO;
  }
  ret = rk_aiq_user_api2_awb_SetWpModeAttrib(rkuvc_aiq_get_ctx(cam_id), attr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.white_blance:white_blance_style", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_white_blance_ct(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.white_blance:white_blance_red", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_white_blance_ct(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  rk_aiq_uapiV2_wb_opMode_t mode_attr;

  rk_aiq_user_api2_awb_GetWpModeAttrib(rkuvc_aiq_get_ctx(cam_id), &mode_attr);
  if (mode_attr.mode == RK_AIQ_WB_MODE_AUTO) {
    LOG_WARN("white blance is auto, not support set color temperature\n");
    return 0;
  }
  ret = rk_aiq_uapi2_setMWBCT(rkuvc_aiq_get_ctx(cam_id), value);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.white_blance:white_blance_ct", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

// enhancement

int rk_isp_get_noise_reduce_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:noise_reduce_mode", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

// Turn off noise reduction, the actual default value is set to 50,
// and it is done in the interface of setting level
int rk_isp_set_noise_reduce_mode(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:noise_reduce_mode", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_dehaze(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:dehaze", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_dehaze(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  // adehaze_sw_V2_t attr;
  // memset(&attr, 0, sizeof(attr));
  // attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
  // if (!strcmp(value, "close")) {
  // 	attr.mode = DEHAZE_API_BYPASS;
  // } else if (!strcmp(value, "open")) {
  // 	attr.mode = DEHAZE_API_MANUAL;
  // } else if (!strcmp(value, "auto")) {
  // 	attr.mode = DEHAZE_API_DEHAZE_AUTO;
  // }
  // ret = rk_aiq_user_api2_adehaze_setSwAttrib(rkuvc_aiq_get_ctx(cam_id),
  // attr);
  snprintf(entry, 127, "isp.%d.enhancement:dehaze", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_gray_scale_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:gray_scale_mode", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_gray_scale_mode(int cam_id, const char *value) {
  int ret;
  char entry[128] = {'\0'};
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  rk_aiq_uapi_acsm_attrib_t attr;
  rk_aiq_user_api2_acsm_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &attr);
  if (!strcmp(value, "[16-235]"))
    attr.param.full_range = false;
  else
    attr.param.full_range = true;
  rk_aiq_user_api2_acsm_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &attr);
  snprintf(entry, 127, "isp.%d.enhancement:gray_scale_mode", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_distortion_correction(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:distortion_correction", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_distortion_correction(int cam_id, const char *value) {
  int ret;
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  rk_aiq_ldch_attrib_t ldchAttr;
  ret = rk_aiq_user_api2_aldch_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &ldchAttr);
  if (!strcmp(value, "close"))
    ldchAttr.en = false;
  else
    ldchAttr.en = true;
  ret = rk_aiq_user_api2_aldch_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &ldchAttr);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:distortion_correction", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_spatial_denoise_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:spatial_denoise_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_spatial_denoise_level(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  const char *noise_reduce_mode;
  rk_aiq_ynr_strength_v3_t ynrStrenght;
  rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;

  rk_isp_get_noise_reduce_mode(cam_id, &noise_reduce_mode);
  LOG_DEBUG("noise_reduce_mode is %s, value is %d\n", noise_reduce_mode, value);
  if ((!strcmp(noise_reduce_mode, "close")) ||
      (!strcmp(noise_reduce_mode, "3dnr"))) {
    value = 50;
    LOG_DEBUG("noise_reduce_mode is %s, value is %d\n", noise_reduce_mode,
              value);
  }
  ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
  ynrStrenght.percent = value / 100.0;
  ret = rk_aiq_user_api2_aynrV3_SetStrength(rkuvc_aiq_get_ctx(cam_id),
                                            &ynrStrenght);
  bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
  bayer2dnrV2Strenght.percent = value / 100.0;
  ret = rk_aiq_user_api2_abayer2dnrV2_SetStrength(rkuvc_aiq_get_ctx(cam_id),
                                                  &bayer2dnrV2Strenght);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:spatial_denoise_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_temporal_denoise_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:temporal_denoise_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_temporal_denoise_level(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  const char *noise_reduce_mode;
  rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;

  rk_isp_get_noise_reduce_mode(cam_id, &noise_reduce_mode);
  LOG_DEBUG("noise_reduce_mode is %s, value is %d\n", noise_reduce_mode, value);
  if ((!strcmp(noise_reduce_mode, "close")) ||
      (!strcmp(noise_reduce_mode, "2dnr"))) {
    value = 50;
    LOG_DEBUG("noise_reduce_mode is %s, value is %d\n", noise_reduce_mode,
              value);
  }
  bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
  bayertnrV2Strenght.percent = value / 100.0;
  ret = rk_aiq_user_api2_abayertnrV2_SetStrength(rkuvc_aiq_get_ctx(cam_id),
                                                 &bayertnrV2Strenght);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:temporal_denoise_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_dehaze_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:dehaze_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_dehaze_level(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  // adehaze_sw_V2_t attr;

  // attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
  // attr.sync.done = false;
  // attr.mode = DEHAZE_API_DEHAZE_MANUAL;
  // attr.stDehazeManu.level = value;
  // int ret = rk_aiq_user_api2_adehaze_setSwAttrib(rkuvc_aiq_get_ctx(cam_id),
  // attr);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:dehaze_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

int rk_isp_get_fec_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:fec_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_fec_level(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  // int ret = rk_aiq_uapi2_setFecCorrectLevel(g_aiq_ctx[cam_id],
  //                                          (int)(value * 2.55)); // [0-100]
  //                                          -> [0->255]
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:fec_level", cam_id);
  rk_param_set_int(entry, value);

  return 0;
}

int rk_isp_get_ldch_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:ldch_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_set_ldch_level(int cam_id, int value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  rk_aiq_ldch_attrib_t ldchAttr;

  value = value < 0 ? 0 : value;
  ret = rk_aiq_user_api2_aldch_GetAttrib(rkuvc_aiq_get_ctx(cam_id), &ldchAttr);
  ldchAttr.correct_level = (int)(value * 2.53 + 2); // [0, 100] -> [2 , 255]
  ret = rk_aiq_user_api2_aldch_SetAttrib(rkuvc_aiq_get_ctx(cam_id), &ldchAttr);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.enhancement:ldch_level", cam_id);
  rk_param_set_int(entry, value);

  return ret;
}

// video_adjustment
int rk_isp_get_power_line_frequency_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.video_adjustment:power_line_frequency_mode",
           cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_power_line_frequency_mode(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret;
  char entry[128] = {'\0'};
  Uapi_ExpSwAttrV2_t expSwAttr;

  ret = rk_aiq_user_api2_ae_getExpSwAttr(rkuvc_aiq_get_ctx(cam_id), &expSwAttr);
  if (!strcmp(value, "NTSC(60HZ)")) {
    expSwAttr.stAuto.stAntiFlicker.enable = true;
    expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_60HZ;
  } else {
    expSwAttr.stAuto.stAntiFlicker.enable = true;
    expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_50HZ;
  }
  ret = rk_aiq_user_api2_ae_setExpSwAttr(rkuvc_aiq_get_ctx(cam_id), expSwAttr);
  snprintf(entry, 127, "isp.%d.video_adjustment:power_line_frequency_mode",
           cam_id);
  //rk_param_set_string(entry, value);

  return ret;
}

int rk_isp_get_image_flip(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.video_adjustment:image_flip", cam_id);
  *value = rk_param_get_string(entry, NULL);

  return 0;
}

int rk_isp_set_image_flip(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret, mirror, flip;
  char entry[128] = {'\0'};
  if (!strcmp(value, "close")) {
    mirror = 0;
    flip = 0;
  }
  if (!strcmp(value, "flip")) {
    mirror = 0;
    flip = 1;
  }
  if (!strcmp(value, "mirror")) {
    mirror = 1;
    flip = 0;
  }
  if (!strcmp(value, "centrosymmetric")) {
    mirror = 1;
    flip = 1;
  }
  rk_aiq_uapi2_setMirrorFlip(rkuvc_aiq_get_ctx(cam_id), mirror, flip, 4); //
  // skip 4 frame
  snprintf(entry, 127, "isp.%d.video_adjustment:image_flip", cam_id);
  rk_param_set_string(entry, value);

  return ret;
}

// auto focus

int rk_isp_get_af_mode(int cam_id, const char **value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.auto_focus:af_mode", cam_id);
  *value = rk_param_get_string(entry, "auto");

  return 0;
}

int rk_isp_set_af_mode(int cam_id, const char *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  char entry[128] = {'\0'};
  opMode_t af_mode = OP_AUTO;
  if (value == NULL)
    return -1;
  if (!strcmp(value, "auto")) {
    af_mode = OP_AUTO;
  } else if (!strcmp(value, "semi-auto")) {
    af_mode = OP_SEMI_AUTO;
  } else if (!strcmp(value, "manual")) {
    af_mode = OP_MANUAL;
  } else {
    return -1;
  }
  ret = rk_aiq_uapi2_setFocusMode(rkuvc_aiq_get_ctx(cam_id), af_mode);
  LOG_INFO("set af mode: %s, ret: %d\n", value, ret);
  snprintf(entry, 127, "isp.%d.auto_focus:af_mode", cam_id);
  rk_param_set_string(entry, value);

  return 0;
}

int rk_isp_get_zoom_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.auto_focus:zoom_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_get_focus_level(int cam_id, int *value) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.auto_focus:focus_level", cam_id);
  *value = rk_param_get_int(entry, -1);

  return 0;
}

int rk_isp_af_zoom_change(int cam_id, int change) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  int code = 0;
  char entry[128] = {'\0'};

  rk_aiq_af_zoomrange af_zoom_range = {0};
  ret = rk_aiq_uapi2_getZoomRange(rkuvc_aiq_get_ctx(cam_id), &af_zoom_range);
  if (ret) {
    LOG_ERROR("get zoom range fail: %d\n", ret);
    return ret;
  }
  rk_aiq_uapi2_getOpZoomPosition(rkuvc_aiq_get_ctx(cam_id), &code);
  code += change;
  if ((code < af_zoom_range.min_pos) || (code > af_zoom_range.max_pos)) {
    LOG_ERROR("set zoom: %d over range [%d, %d]\n", code, af_zoom_range.min_pos,
              af_zoom_range.max_pos);
    ret = -1;
  }
  ret = rk_aiq_uapi2_setOpZoomPosition(rkuvc_aiq_get_ctx(cam_id), code);
  LOG_INFO("set zoom: %d, ret: %d\n", code, ret);
  snprintf(entry, 127, "isp.%d.auto_focus:zoom_level", cam_id);
  rk_param_set_int(entry, code);

  return ret;
}

int rk_isp_af_focus_change(int cam_id, int change) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  short code = 0;
  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.auto_focus:af_mode", cam_id);
  const char *af_mode = rk_param_get_string(entry, "auto");
  if (!strcmp(af_mode, "auto"))
    return 0;

  rk_aiq_af_focusrange af_focus_range = {0};
  ret = rk_aiq_uapi2_getFocusRange(rkuvc_aiq_get_ctx(cam_id), &af_focus_range);
  if (ret) {
    LOG_ERROR("get focus range fail: %d\n", ret);
    return ret;
  }
  rk_aiq_uapi2_getFocusPosition(rkuvc_aiq_get_ctx(cam_id), &code);
  code += change;
  if ((code < af_focus_range.min_pos) || (code > af_focus_range.max_pos)) {
    LOG_ERROR("before set getFocusPosition: %d over range (%d, %d)\n", code,
              af_focus_range.min_pos, af_focus_range.max_pos);
    return -1;
  }
  ret = rk_aiq_uapi2_setFocusPosition(rkuvc_aiq_get_ctx(cam_id), code);
  LOG_INFO("set setFocusPosition: %d, ret: %d\n", code, ret);
  snprintf(entry, 127, "isp.%d.auto_focus:focus_level", cam_id);
  rk_param_set_int(entry, code);

  return ret;
}

int rk_isp_af_zoom_in(int cam_id) { return rk_isp_af_zoom_change(cam_id, 20); }

int rk_isp_af_zoom_out(int cam_id) {
  return rk_isp_af_zoom_change(cam_id, -20);
}

int rk_isp_af_focus_in(int cam_id) { return rk_isp_af_focus_change(cam_id, 1); }

int rk_isp_af_focus_out(int cam_id) {
  return rk_isp_af_focus_change(cam_id, -1);
}

int rk_isp_af_focus_once(int cam_id) {
  LOG_INFO("af_focus_once\n");
  return rk_aiq_uapi2_endOpZoomChange(rkuvc_aiq_get_ctx(cam_id));
}

int rk_isp_set_from_ini(int cam_id) {
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  int ret = 0;
  LOG_INFO("start\n");
  rk_isp_set_frame_rate(cam_id, rk_param_get_int("isp.0.adjustment:fps", 30));
  // rk_isp_set_contrast(cam_id, rk_param_get_int("isp.0.adjustment:contrast",
  // 50));
  // rk_isp_set_brightness(cam_id,
  // rk_param_get_int("isp.0.adjustment:brightness", 50));
  // rk_isp_set_saturation(cam_id,
  // rk_param_get_int("isp.0.adjustment:saturation", 50));
  // rk_isp_set_sharpness(cam_id, rk_param_get_int("isp.0.adjustment:sharpness",
  // 50));
  // rk_isp_set_hue(cam_id, rk_param_get_int("isp.0.adjustment:hue", 50));
  LOG_INFO("end\n");

  return ret;
}

int rk_isp_init(int cam_id, char *iqfile_path) {
  LOG_INFO("cam_id is %d\n", cam_id);
  int ret;
  rkuvc_aiq_use_group = 0;
  if (iqfile_path)
    memcpy(g_iq_file_dir_, iqfile_path, strlen(iqfile_path));
  else
    memcpy(g_iq_file_dir_, "/etc/iqfiles", strlen("/etc/iqfiles"));
  LOG_INFO("g_iq_file_dir_ is %s\n", g_iq_file_dir_);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr", cam_id);
  const char *hdr_mode = rk_param_get_string(entry, "close");
  LOG_INFO("cam_id is %d, hdr_mode is %s\n", cam_id, hdr_mode);
  if (!strcmp(hdr_mode, "HDR2")) {
    ret = sample_common_isp_init(cam_id, RK_AIQ_WORKING_MODE_ISP_HDR2, true,
                                 g_iq_file_dir_);
    // rk_aiq_uapi2_sysctl_switch_scene(g_aiq_ctx[cam_id], "hdr" , "day");
  } else {
    ret = sample_common_isp_init(cam_id, RK_AIQ_WORKING_MODE_NORMAL, true,
                                 g_iq_file_dir_);
    // rk_aiq_uapi2_sysctl_switch_scene(g_aiq_ctx[cam_id], "normal" , "day");
  }

  ret |= sample_common_isp_run(cam_id);
  ret |= rk_isp_set_from_ini(cam_id);

  return ret;
}

int rk_isp_deinit(int cam_id) {
  LOG_INFO("cam_id is %d\n", cam_id);
  RK_ISP_CHECK_CAMERA_ID(cam_id);
  LOG_INFO("rk_aiq_uapi2_sysctl_stop enter\n");
  rk_aiq_uapi2_sysctl_stop(g_aiq_ctx[cam_id], false);
  LOG_INFO("rk_aiq_uapi2_sysctl_deinit enter\n");
  rk_aiq_uapi2_sysctl_deinit(g_aiq_ctx[cam_id]);
  LOG_INFO("rk_aiq_uapi2_sysctl_deinit exit\n");
  g_aiq_ctx[cam_id] = NULL;

  return 0;
}

int rk_isp_group_init(int cam_group_id, char *iqfile_path) {
  LOG_INFO("cam_group_id is %d\n", cam_group_id);
  int ret;
  rkuvc_aiq_use_group = 1;
  if (iqfile_path)
    memcpy(g_iq_file_dir_, iqfile_path, strlen(iqfile_path));
  else
    memcpy(g_iq_file_dir_, "/etc/iqfiles", strlen("/etc/iqfiles"));
  LOG_INFO("g_iq_file_dir_ is %s\n", g_iq_file_dir_);

  char entry[128] = {'\0'};
  snprintf(entry, 127, "isp.%d.blc:hdr", cam_group_id);
  const char *hdr_mode = rk_param_get_string(entry, "close");
  LOG_INFO("cam_group_id is %d, hdr_mode is %s\n", cam_group_id, hdr_mode);
  if (!strcmp(hdr_mode, "HDR2")) {
    ret = isp_camera_group_init(cam_group_id, RK_AIQ_WORKING_MODE_ISP_HDR2,
                                false, g_iq_file_dir_);
  } else {
    ret = isp_camera_group_init(cam_group_id, RK_AIQ_WORKING_MODE_NORMAL, false,
                                g_iq_file_dir_);
  }
  ret |= rk_isp_set_from_ini(cam_group_id);

  return ret;
}

int rk_isp_group_deinit(int cam_group_id) {
  LOG_INFO("cam_group_id is %d\n", cam_group_id);
  return isp_camera_group_stop(cam_group_id);
}