#if CONFIG_DBSERVER
#include <errno.h>
#include <gdbus.h>
#include <glib.h>
#include <linux/kernel.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../utils/log.h"
#include "config.h"
#include "isp_func.h"
#include "mediactl/mediactl.h"
#include "rkaiq/common/rk_aiq_comm.h"
#include "rkaiq/uAPI/rk_aiq_user_api_ae.h"
#include "rkaiq/uAPI/rk_aiq_user_api_sysctl.h"

#if ENABLE_MEDIASERVER
#include "mediaserver.h"
#endif

extern rk_aiq_sys_ctx_t *db_aiq_ctx;

rk_aiq_wb_gain_t gs_wb_gain = {2.083900, 1.000000, 1.000000, 2.018500};
static pthread_mutex_t db_aiq_ctx_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t cpsl_cfg_mutex = PTHREAD_MUTEX_INITIALIZER;

rk_aiq_working_mode_t gc_hdr_mode = RK_AIQ_WORKING_MODE_NORMAL;
static rk_aiq_cpsl_cfg_t gc_cpsl_cfg;
static int gc_cpsl_cfg_init_flag = 0;
static expPwrLineFreq_t gc_frequency_mode = EXP_PWR_LINE_FREQ_60HZ;
static int gc_led_mode = LED_OFF;
static work_mode_2_t gc_dehaze_mode = WM2_INVALID_MODE;
static dc_mode_t gc_dc_mode = DC_INVALID;
static int g_stream_on = 0;
static int g_fix_fps = -1;
static ispserver_status_signal_send g_send_func = NULL;
float exposure_uvc_time[10] = {0.0005f, 0.001f,  0.002f,  0.0039f, 0.0078f,
                               0.0156f, 0.0312f, 0.0625f, 0.1250f, 0.2500f};
float exposure_isp_time[10] = {0.0005f, 0.001f,  0.002f,  0.0039f, 0.0078f,
                               0.0100f, 0.0150f, 0.0200f, 0.0250f, 0.0300f};

static void set_led_state(int status) { gc_led_mode = status; }

int get_led_state() { return gc_led_mode; }

void send_stream_on_signal() {
  if (g_send_func) {
    g_send_func(1);
  }
}

void set_stream_on() {
  if (!g_stream_on && g_send_func) {
    g_send_func(1);
  }
  g_stream_on = 1;
}

void set_stream_off() {
  if (g_stream_on && g_send_func) {
    g_send_func(0);
  }
  g_stream_on = 0;
}

int check_stream_status() {
  return g_stream_on;
}

void reset_flow() {
#if ENABLE_MEDIASERVER
  set_stream_off();
  mediaserver_stop_flow();
  while (!g_stream_on) {
    usleep(100);
  }
  mediaserver_restart_flow();
  LOG_INFO("reset flow end!\n");
#else
  LOG_ERROR("no mediaserver, reset flow fail, please overwrite reset_flow in "
            "isp_func.c\n");
#endif
}

void brightness_set(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_uapi_setBrightness(db_aiq_ctx,
                            (int)(level * 2.55)); // [0, 100]->[0, 255]
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
}

void contrast_set(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_uapi_setContrast(db_aiq_ctx,
                          (int)(level * 2.55)); // [0, 100]->[0, 255]
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
}

void saturation_set(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_uapi_setSaturation(db_aiq_ctx,
                            (int)(level * 2.55)); // [0, 100]->[0, 255]
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
}

void sharpness_set(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_uapi_setSharpness(db_aiq_ctx, level); // [0, 100]
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
}

void hue_set(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_uapi_setHue(db_aiq_ctx, (int)(level * 2.55)); // [0, 100]->[0, 255]
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
}

int manual_white_balance_level_set(int r_level, int g_level, int b_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  rk_aiq_wb_gain_t gain;
  float ratio_r, ratio_g, ratio_b;
  r_level = (r_level == 0) ? 1 : r_level;
  g_level = (g_level == 0) ? 1 : g_level;
  b_level = (b_level == 0) ? 1 : b_level;

  gain.rgain = r_level / 50.0f * gs_wb_gain.rgain;   // [0, 100]->[1.0, 4.0]
  gain.grgain = g_level / 50.0f * gs_wb_gain.grgain; // [0, 100]->[1.0, 4.0]
  gain.gbgain = g_level / 50.0f * gs_wb_gain.gbgain; // [0, 100]->[1.0, 4.0]
  gain.bgain = b_level / 50.0f * gs_wb_gain.bgain;   // [0, 100]->[1.0, 4.0]
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = rk_aiq_uapi_setMWBGain(db_aiq_ctx, &gain);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("r_level is %d, g_level is %d, b_level is %d, set ret is %d\n",
           r_level, g_level, b_level, ret);
  return ret;
}

int manual_white_balance_set(int r_level, int g_level, int b_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = rk_aiq_uapi_setWBMode(db_aiq_ctx, OP_MANUAL);
  LOG_DEBUG("set white balance mode manual, ret is %d\n", ret);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  ret = manual_white_balance_level_set(r_level, g_level, b_level);
  return ret;
}

int white_balance_style_set(white_balance_mode_t style) {
  LOG_DEBUG("white balance style is %d\n", style);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  if (style != WB_LOCK) {
    ret = rk_aiq_uapi_unlockAWB(db_aiq_ctx);
    LOG_DEBUG("set unlock white balance, ret is %d\n", ret);
  }
  switch (style) {
  case WB_INVALID: {
    LOG_WARN("set invalid white balance mode\n");
    break;
  }
  case WB_AUTO: {
    ret = rk_aiq_uapi_setWBMode(db_aiq_ctx, OP_AUTO);
    LOG_INFO("set autoWhiteBalance, ret is %d\n", ret);
    break;
  }
  case WB_MANUAL: {
    ret = rk_aiq_uapi_setWBMode(db_aiq_ctx, OP_MANUAL);
    LOG_INFO("set manualWhiteBalance, without level, ret is %d\n", ret);
    break;
  }
  case WB_LOCK: {
    ret = rk_aiq_uapi_lockAWB(db_aiq_ctx);
    LOG_INFO("set lock whilte balance, ret is %d\n", ret);
    break;
  }
  case WB_FLUORESCENT_LAMP: {
    ret = rk_aiq_uapi_setMWBScene(db_aiq_ctx, RK_AIQ_WBCT_DAYLIGHT);
    LOG_INFO("set fluorescentLamp, ret is %d\n", ret);
    break;
  }
  case WB_INCANDESCENT: {
    ret = rk_aiq_uapi_setMWBScene(db_aiq_ctx, RK_AIQ_WBCT_INCANDESCENT);
    LOG_INFO("set incandescent, ret is %d\n", ret);
    break;
  }
  case WB_WARM_LIGHT: {
    ret = rk_aiq_uapi_setMWBScene(db_aiq_ctx, RK_AIQ_WBCT_WARM_FLUORESCENT);
    LOG_INFO("set warmLight, ret is %d\n", ret);
    break;
  }
  case WB_NATURE_LIGHT: {
    rk_aiq_uapi_setMWBCT(db_aiq_ctx, 5500);
    LOG_INFO("set naturalLight, ret is %d\n", ret);
    break;
  }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

static int isp_output_fps_set_no_mutex(int rate) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  if (g_fix_fps > 0)
    rate = g_fix_fps;
  int ret = 0;
  frameRateInfo_t info;
  memset(&info, 0, sizeof(info));
  rk_aiq_uapi_getFrameRate(db_aiq_ctx, &info);
  if (info.fps != rate) {
    info.fps = rate;
    info.mode = OP_MANUAL;
    ret = rk_aiq_uapi_setFrameRate(db_aiq_ctx, info);
  }
  LOG_INFO("set output fps: %d, ret is %d\n", rate, ret);
  return ret;
}

static int isp_output_fps_set(int rate) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = isp_output_fps_set_no_mutex(rate);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

static int isp_output_fps_get() {
  if (g_fix_fps > 0) {
    LOG_INFO("fps is fixed, rate is %d\n", g_fix_fps);
    return g_fix_fps;
  }
  int fps = 30;
  switch (gc_hdr_mode) {
  case RK_AIQ_WORKING_MODE_NORMAL: {
    fps = (gc_frequency_mode == EXP_PWR_LINE_FREQ_50HZ ? 25 : 30);
    break;
  }
  case RK_AIQ_WORKING_MODE_ISP_HDR2: {
    fps = 25;
    break;
  }
  case RK_AIQ_WORKING_MODE_ISP_HDR3: {
    fps = 20;
    break;
  }
  default: {
    fps = 30;
    break;
  }
  }

  return fps;
}

int isp_fix_fps_set(int rate) {
  g_fix_fps = rate;
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  if (g_fix_fps > 0) {
    pthread_mutex_lock(&db_aiq_ctx_mutex);
    ret = isp_output_fps_set_no_mutex(rate);
    pthread_mutex_unlock(&db_aiq_ctx_mutex);
  } else {
    ret = isp_output_fps_set(isp_output_fps_get());
  }
  return ret;
}

int frequency_mode_set(expPwrLineFreq_t mode) {
  LOG_INFO("frequency mode is %d\n", mode);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (mode) {
  case EXP_PWR_LINE_FREQ_50HZ: {
    ret = rk_aiq_uapi_setExpPwrLineFreqMode(db_aiq_ctx, EXP_PWR_LINE_FREQ_50HZ);
    LOG_DEBUG("rk_aiq_uapi_setExpPwrLineFreqMode 50HZ ret is %d\n", ret);
    isp_output_fps_set_no_mutex(25);
    gc_frequency_mode = EXP_PWR_LINE_FREQ_50HZ;
    break;
  }
  case EXP_PWR_LINE_FREQ_60HZ: {
    ret = rk_aiq_uapi_setExpPwrLineFreqMode(db_aiq_ctx, EXP_PWR_LINE_FREQ_60HZ);
    LOG_DEBUG("rk_aiq_uapi_setExpPwrLineFreqMode 60HZ ret is %d\n", ret);
    isp_output_fps_set_no_mutex(30);
    gc_frequency_mode = EXP_PWR_LINE_FREQ_60HZ;
    break;
  }
  default: { LOG_WARN("set undefined frequencncy mode: %d\n", mode); }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int hdr_global_value_set(rk_aiq_working_mode_t hdr_mode) {
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (hdr_mode) {
    case RK_AIQ_WORKING_MODE_NORMAL:
      gc_hdr_mode = RK_AIQ_WORKING_MODE_NORMAL;
      break;
    case RK_AIQ_WORKING_MODE_ISP_HDR2:
      gc_hdr_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
      break;
    case RK_AIQ_WORKING_MODE_ISP_HDR3:
      gc_hdr_mode = RK_AIQ_WORKING_MODE_ISP_HDR3;
      break;
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return 0;
}

rk_aiq_working_mode_t hdr_global_value_get() {
  return gc_hdr_mode;
}

int hdr2_normal_set(rk_aiq_working_mode_t hdr_mode) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (hdr_mode) {
  case RK_AIQ_WORKING_MODE_NORMAL: {
    ret = rk_aiq_uapi_sysctl_swWorkingModeDyn(db_aiq_ctx,
                                              RK_AIQ_WORKING_MODE_NORMAL);
    gc_hdr_mode = RK_AIQ_WORKING_MODE_NORMAL;
    LOG_INFO("set hdr off ,ret is %d, gc_hdr_mode\n", ret, gc_hdr_mode);
    break;
  }
  case RK_AIQ_WORKING_MODE_ISP_HDR2: {
    ret = rk_aiq_uapi_sysctl_swWorkingModeDyn(db_aiq_ctx,
                                              RK_AIQ_WORKING_MODE_ISP_HDR2);
    gc_hdr_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
    LOG_INFO("set hdr2 ,ret is %d, gc_hdr_mode\n", ret, gc_hdr_mode);
    break;
  }
  default: { LOG_WARN("set undefined mode: %d\n", hdr_mode); }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

// TODO: hdr3 mode and restart flow
void hdr_mode_set(rk_aiq_working_mode_t mode, int ledIsOn) {
  LOG_INFO("set hdr mode %d, led status %d, gc_hdr_mode is %d\n", mode, ledIsOn,
           gc_hdr_mode);
  if (gc_hdr_mode == mode || (LED_ON == get_led_state() && 1 == ledIsOn)) {
    LOG_DEBUG("find no change in mode\n");
    return;
  }
  if (gc_hdr_mode == RK_AIQ_WORKING_MODE_ISP_HDR3 ||
      mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
    LOG_INFO("set hdr3\n");
    gc_hdr_mode = mode;
    reset_flow();
    // reboot?
    // rk_restart_image_process(hdr_mode);
  } else {
    hdr2_normal_set(mode);
    isp_output_fps_set(isp_output_fps_get());
  }
}

void hdr_mode_set4db(rk_aiq_working_mode_t mode) {
  hdr_mode_set(mode, gc_led_mode);
}

int blc_hdr_level_set(int level) {
  LOG_INFO("set level is %d\n", level);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  if (level)
    ret = rk_aiq_uapi_setMHDRStrth(db_aiq_ctx, true, level);
  else
    ret = rk_aiq_uapi_setMHDRStrth(db_aiq_ctx, true, 1);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int blc_hdr_level_enum_set(unsigned int level) {
  ahdr_attrib_t attr;
  Uapi_HdrExpAttr_t hdrExpAttr;
  LOG_DEBUG("set hdr level: %d, gc_hdr_mode: %d\n", level, gc_hdr_mode);
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  if (db_aiq_ctx && g_stream_on) {
    switch (level) {
    case 1: // auto
      rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
      // attr.bEnable = true;
      attr.opMode = HDR_OpMode_SET_LEVEL;
      attr.stSetLevel.level = 50;
      rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

      rk_aiq_user_api_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
      hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO;
      rk_aiq_user_api_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
      break;
    case 2:
      rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
      // attr.bEnable = true;
      attr.opMode = HDR_OpMode_SET_LEVEL;
      attr.stSetLevel.level = 40;
      rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

      rk_aiq_user_api_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
      hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
      hdrExpAttr.M2SRatioFix.fCoeff[0] = 28;
      hdrExpAttr.M2SRatioFix.fCoeff[1] = 28;
      hdrExpAttr.M2SRatioFix.fCoeff[2] = 28;
      hdrExpAttr.M2SRatioFix.fCoeff[3] = 28;
      hdrExpAttr.M2SRatioFix.fCoeff[4] = 28;
      hdrExpAttr.M2SRatioFix.fCoeff[5] = 28;
      rk_aiq_user_api_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
      break;
    case 3:
      rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
      // attr.bEnable = true;
      attr.opMode = HDR_OpMode_SET_LEVEL;
      attr.stSetLevel.level = 55;
      rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

      rk_aiq_user_api_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
      hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
      hdrExpAttr.M2SRatioFix.fCoeff[0] = 32;
      hdrExpAttr.M2SRatioFix.fCoeff[1] = 32;
      hdrExpAttr.M2SRatioFix.fCoeff[2] = 32;
      hdrExpAttr.M2SRatioFix.fCoeff[3] = 32;
      hdrExpAttr.M2SRatioFix.fCoeff[4] = 32;
      hdrExpAttr.M2SRatioFix.fCoeff[5] = 32;
      rk_aiq_user_api_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
      break;
    case 4:
      rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
      // attr.bEnable = true;
      attr.opMode = HDR_OpMode_SET_LEVEL;
      attr.stSetLevel.level = 68;
      rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

      rk_aiq_user_api_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
      hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
      hdrExpAttr.M2SRatioFix.fCoeff[0] = 48;
      hdrExpAttr.M2SRatioFix.fCoeff[1] = 48;
      hdrExpAttr.M2SRatioFix.fCoeff[2] = 48;
      hdrExpAttr.M2SRatioFix.fCoeff[3] = 48;
      hdrExpAttr.M2SRatioFix.fCoeff[4] = 48;
      hdrExpAttr.M2SRatioFix.fCoeff[5] = 48;
      rk_aiq_user_api_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
      break;
    case 5:
#if 0
                rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
                attr.bEnable = true;
                attr.opMode = HDR_OpMode_SET_LEVEL;
                attr.level = 80;
                rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

                rk_aiq_uapi_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
                hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
                hdrExpAttr.M2SRatioFix.fCoeff[0] = 16;
                hdrExpAttr.M2SRatioFix.fCoeff[1] = 16;
                hdrExpAttr.M2SRatioFix.fCoeff[2] = 16;
                hdrExpAttr.M2SRatioFix.fCoeff[3] = 16;
                hdrExpAttr.M2SRatioFix.fCoeff[4] = 16;
                hdrExpAttr.M2SRatioFix.fCoeff[5] = 16;

                hdrExpAttr.L2MRatioFix.fCoeff[0] = 4;
                hdrExpAttr.L2MRatioFix.fCoeff[1] = 4;
                hdrExpAttr.L2MRatioFix.fCoeff[2] = 4;
                hdrExpAttr.L2MRatioFix.fCoeff[3] = 4;
                hdrExpAttr.L2MRatioFix.fCoeff[4] = 4;
                hdrExpAttr.L2MRatioFix.fCoeff[5] = 4;
                rk_aiq_uapi_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
#else
      rk_aiq_user_api_ahdr_GetAttrib(db_aiq_ctx, &attr);
      // attr.bEnable = true;
      attr.opMode = HDR_OpMode_SET_LEVEL;
      attr.stSetLevel.level = 50;
      rk_aiq_user_api_ahdr_SetAttrib(db_aiq_ctx, attr);

      rk_aiq_user_api_ae_getHdrExpAttr(db_aiq_ctx, &hdrExpAttr);
      hdrExpAttr.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO;
      rk_aiq_user_api_ae_setHdrExpAttr(db_aiq_ctx, hdrExpAttr);
#endif
      break;
    default:
      LOG_WARN("HDR_LEVEL: %d\n", level);
      break;
    }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return 0;
}

int32_t str2time_sec(char *time_str) {
  if (NULL == time_str || (strlen(time_str) != 8 && strlen(time_str) != 5))
    return -1;
  int32_t second_rst = -1;
  if (strlen(time_str) != 8) {
    char hour_str[3] = {0};
    char minute_str[3] = {0};
    char second_str[3] = {0};
    strncpy(hour_str, time_str, 2);
    strncpy(minute_str, time_str + 3, 2);
    strncpy(second_str, time_str + 5, 2);
    int hour = atoi(hour_str);
    int minute = atoi(minute_str);
    int second = atoi(second_str);
    second_rst = (hour * 60 * 60) + (minute * 60) + second;
  } else {
    char hour_str[3] = {0};
    char minute_str[3] = {0};
    strncpy(hour_str, time_str, 2);
    strncpy(minute_str, time_str + 3, 2);
    int hour = atoi(hour_str);
    int minute = atoi(minute_str);
    second_rst = (hour * 60 * 60) + (minute * 60);
  }

  return second_rst;
}

void gc_cpsl_cfg_fill_light_mode_set(rk_aiq_cpsls_t mode) {
  pthread_mutex_lock(&cpsl_cfg_mutex);
  if (!gc_cpsl_cfg_init_flag)
    memset(&gc_cpsl_cfg, 0, sizeof(rk_aiq_cpsl_cfg_t));
  if (mode != RK_AIQ_CPSLS_INVALID)
    gc_cpsl_cfg.lght_src = mode;
  else if (!gc_cpsl_cfg_init_flag) {
    gc_cpsl_cfg.lght_src = RK_AIQ_CPSLS_IR;
    LOG_WARN("fill mode: %d is undefined, set ir by default\n", mode);
  }
  gc_cpsl_cfg_init_flag = 1;
  pthread_mutex_unlock(&cpsl_cfg_mutex);
}

// TODO: for night to day change
int rk_smart_get_scene_param(double *pdLumaDay, double *pdLumaNight,
                             double *pdRGratio, double *pdBGratio,
                             unsigned int *p_u32_exposure, double *pdExpAgain) {
  return 0;
}

int night_to_day_para_set(rk_aiq_cpsl_cfg_t compensate_light_cfg) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  if (compensate_light_cfg.mode != RK_AIQ_OP_MODE_INVALID) {
    pthread_mutex_lock(&db_aiq_ctx_mutex);
    ret = rk_aiq_uapi_sysctl_setCpsLtCfg(db_aiq_ctx, &compensate_light_cfg);
    pthread_mutex_unlock(&db_aiq_ctx_mutex);
    LOG_DEBUG("set night to day para, ret is %d\n", ret);
  } else {
    LOG_INFO("compensate_light_cfg.mode is invalid\n");
  }
  return ret;
}

int fill_light_brightness_set(int strength) {
  pthread_mutex_lock(&cpsl_cfg_mutex);
  if (!gc_cpsl_cfg_init_flag)
    gc_cpsl_cfg_fill_light_mode_set(RK_AIQ_CPSLS_IR);
  gc_cpsl_cfg.u.m.strength_led = strength / 5 + 3;
  gc_cpsl_cfg.u.m.strength_ir = strength / 5 + 3;
  int ret = night_to_day_para_set(gc_cpsl_cfg);
  pthread_mutex_unlock(&cpsl_cfg_mutex);
  LOG_INFO("set fill light brightness %d, ret is %d\n", strength, ret);
  return ret;
}

int set_gray_open_led(int fill_light_brightness) {
  int ret = -1;
  pthread_mutex_lock(&cpsl_cfg_mutex);
  gc_cpsl_cfg.mode = RK_AIQ_OP_MODE_MANUAL;
  gc_cpsl_cfg.gray_on = true;
  gc_cpsl_cfg.u.m.on = 1;
  gc_cpsl_cfg.u.m.strength_led = fill_light_brightness / 5 + 3;
  gc_cpsl_cfg.u.m.strength_ir = fill_light_brightness / 5 + 3;
  ret = night_to_day_para_set(gc_cpsl_cfg);
  pthread_mutex_unlock(&cpsl_cfg_mutex);
  LOG_DEBUG("set gray open, ret is %d\n", ret);
  return ret;
}

int set_color_close_led() {
  int ret = -1;
  pthread_mutex_lock(&cpsl_cfg_mutex);
  if (!gc_cpsl_cfg_init_flag)
    gc_cpsl_cfg_fill_light_mode_set(RK_AIQ_CPSLS_IR);
  gc_cpsl_cfg.mode = RK_AIQ_OP_MODE_MANUAL;
  gc_cpsl_cfg.gray_on = false;
  gc_cpsl_cfg.u.m.on = 0;
  gc_cpsl_cfg.u.m.strength_led = 0;
  gc_cpsl_cfg.u.m.strength_ir = 0;
  ret = night_to_day_para_set(gc_cpsl_cfg);
  pthread_mutex_unlock(&cpsl_cfg_mutex);
  LOG_DEBUG("set color close, ret is %d\n", ret);
  return ret;
}

int night_to_day_auto_mode_set(int filter_level, int filter_time) {
  int ret = -1;
  pthread_mutex_lock(&cpsl_cfg_mutex);
  if (!gc_cpsl_cfg_init_flag)
    gc_cpsl_cfg_fill_light_mode_set(RK_AIQ_CPSLS_IR);
  gc_cpsl_cfg.mode = RK_AIQ_OP_MODE_AUTO;
  gc_cpsl_cfg.gray_on = false;
  gc_cpsl_cfg.u.a.sensitivity = (float)filter_level;
  gc_cpsl_cfg.u.a.sw_interval = (uint32_t)filter_time;
  ret = night_to_day_para_set(gc_cpsl_cfg);
  pthread_mutex_unlock(&cpsl_cfg_mutex);
  LOG_INFO("set night to day auto mode, ret is %d\n", ret);
  return ret;
}

int set_night_mode(int fill_light_brightness) {
  int ret = -1;
  ret = set_gray_open_led(fill_light_brightness);
  LOG_INFO("set night mode, ret is %d\n", ret);
  set_led_state(LED_ON);
  if (gc_hdr_mode != RK_AIQ_WORKING_MODE_NORMAL) {
    hdr_mode_set(RK_AIQ_WORKING_MODE_NORMAL, 0);
    LOG_INFO("switch to hdr normal in night mode\n");
  }
  return ret;
}

int set_day_mode(int hdr_mode) {
  int ret = -1;
  ret = set_color_close_led();
  LOG_INFO("set day mode, ret is %d\n", ret);
  set_led_state(LED_OFF);
  // TODO:get WideDynamicLevel only set hdr2 now
  if (hdr_mode == RK_AIQ_WORKING_MODE_ISP_HDR3) {
    hdr_mode_set(RK_AIQ_WORKING_MODE_ISP_HDR3, 0);
    LOG_INFO("set hdr3 when switching to day mode\n");
  } else if (hdr_mode == RK_AIQ_WORKING_MODE_ISP_HDR2) {
    hdr_mode_set(RK_AIQ_WORKING_MODE_ISP_HDR2, 0);
    LOG_INFO("set hdr2 when switching to day mode\n");
  }
  return ret;
}

int bypass_stream_rotation_set(int rotation) {
  LOG_INFO("rotation: %d\n", rotation);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  rk_aiq_rotation_t rk_rotation = RK_AIQ_ROTATION_0;
  if (rotation == 0) {
    rk_rotation = RK_AIQ_ROTATION_0;
  } else if (rotation == 90) {
    rk_rotation = RK_AIQ_ROTATION_90;
  } else if (rotation == 270) {
    rk_rotation = RK_AIQ_ROTATION_270;
  } else {
    LOG_INFO("invalid roation value %d, set 0 by default\n", rotation);
  }

  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = rk_aiq_uapi_sysctl_setSharpFbcRotation(db_aiq_ctx, rk_rotation);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);

  LOG_DEBUG("set rotation ret is %d\n", ret);
  return ret;
}

int mirror_mode_set(flip_mode_t mode) {
  LOG_INFO("set mirror mode %d\n", mode);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int mirror = 0;
  int flip = 0;
  switch (mode) {
  case FM_INVALID: {
    return -1;
  }
  case FM_CLOSE: {
    break;
  }
  case FM_FLIP: {
    flip = 1;
    break;
  }
  case FM_MIRROR: {
    mirror = 1;
    break;
  }
  case FM_CENTER: {
    flip = 1;
    mirror = 1;
    break;
  }
  }
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = rk_aiq_uapi_setMirroFlip(db_aiq_ctx, mirror, flip, 4);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("set mirror %d, set flip %d, ret is %d\n", mirror, flip, ret);
  return ret;
}

static int nr_level_set_no_mutex(int spatial_level, int temporal_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  if (spatial_level >= 0) {
    ret = rk_aiq_uapi_setMSpaNRStrth(db_aiq_ctx, true, spatial_level); //[0,100]
    LOG_DEBUG("rk_aiq_uapi_setMSpaNRStrth level is %d, ret is %d\n",
              spatial_level, ret);
  }

  if (temporal_level >= 0) {
    ret = rk_aiq_uapi_setMTNRStrth(db_aiq_ctx, true, temporal_level); //[0,100]
    LOG_DEBUG("rk_aiq_uapi_setMTNRStrth level is %d, ret is %d\n",
              temporal_level, ret);
  }
  return ret;
}

int nr_level_set(int spatial_level, int temporal_level) {
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = nr_level_set_no_mutex(spatial_level, temporal_level);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int nr_para_set(nr_mode_t mode, int spatial_level, int temporal_level) {
  LOG_DEBUG("mode is %d, spatial level is %d, temporal level is %d\n", mode,
            spatial_level, temporal_level);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = rk_aiq_uapi_sysctl_setModuleCtl(db_aiq_ctx, RK_MODULE_NR, true); // 2D
  LOG_DEBUG("rk_aiq_uapi_sysctl_setModuleCtl 2d ret is %d\n", ret);
  ret = rk_aiq_uapi_sysctl_setModuleCtl(db_aiq_ctx, RK_MODULE_TNR, true); // 3D
  LOG_DEBUG("rk_aiq_uapi_sysctl_setModuleCtl 3d ret is %d\n", ret);
  switch (mode) {
  case NR_INVAILD: {
    LOG_WARN("set invalide nr mode\n");
    pthread_mutex_unlock(&db_aiq_ctx_mutex);
    return -1;
  }
  case NR_DEFAULT: {
    spatial_level = DEFAULT_SPATIAL_DENOIZE_LEVEL;
    temporal_level = DEFAULT_TEMPORAL_DENOIZE_LEVEL;
    break;
  }
  case NR_2D: {
    temporal_level = DEFAULT_TEMPORAL_DENOIZE_LEVEL;
    break;
  }
  case NR_3D: {
    spatial_level = DEFAULT_SPATIAL_DENOIZE_LEVEL;
    break;
  }
  case NR_MIX: {
    break;
  }
  default: {
    spatial_level = DEFAULT_SPATIAL_DENOIZE_LEVEL;
    temporal_level = DEFAULT_TEMPORAL_DENOIZE_LEVEL;
    LOG_WARN("undefined nr mode %d. use default instead\n", mode);
    break;
  }
  }
  if (!ret) {
    ret = nr_level_set_no_mutex(spatial_level, temporal_level);
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

static int ldch_level_set_no_mutex(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  level = level < 0 ? 0 : level;
  level = (int)(level * 2.53 + 2);
  int ret = rk_aiq_uapi_setLdchCorrectLevel(db_aiq_ctx,
                                            level); // [1, 100] -> [2 , 255]
  LOG_DEBUG("set ldch level %d ret is %d\n", level, ret);
  return ret;
}

int ldch_level_set(int level) {
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = ldch_level_set_no_mutex(level);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("set ldch level %d, ret is %d\n", level, ret);
  return ret;
}

/* not support modify dynamic */
static int fec_switch_no_mutex(bool swi) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  rk_aiq_fec_attrib_t attr;
  int ret = -1;
  ret = rk_aiq_uapi_setFecEn(db_aiq_ctx, swi);
  LOG_DEBUG("switch fec %d, ret: %d\n", swi, ret);
  return ret;
}

void gc_dc_mode_set(dc_mode_t mode) { gc_dc_mode = mode; }

static int fec_level_set_no_mutex(int fec_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  fec_level = fec_level < 0 ? 0 : fec_level;
  fec_level = fec_level * 2.55;
  fec_level = fec_level > 255 ? 255 : fec_level;
  int ret = rk_aiq_uapi_setFecCorrectLevel(db_aiq_ctx,
                                           fec_level); // [0-100] -> [0->255]
  LOG_DEBUG("set fec level:%d, ret is %d\n", fec_level, ret);
}

int fec_level_set(int fec_level) {
  if (gc_dc_mode != DC_FEC) {
    LOG_INFO("no in fec mode, set level fail\n");
    return -1;
  }
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = fec_level_set_no_mutex(fec_level);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int dc_para_set(dc_mode_t mode, int ldch_level, int fec_level) {
  LOG_INFO("mode is %d, ldch_level is %d, fec_level is %d\n", mode, ldch_level,
           fec_level);
  if (!db_aiq_ctx || !g_stream_on) {
    return -1;
  }
  int ret = 0;
  int reset_flag = 0;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (mode) {
  case DC_INVALID: {
    LOG_WARN("set invalid distortion correction mode\n");
    ret = -1;
    break;
  }
  case DC_LDCH: {
    if (gc_dc_mode == DC_FEC) {
      reset_flag = 1;
      LOG_INFO("close fec ret is %d\n", ret);
    } else {
      ret = rk_aiq_uapi_setLdchEn(db_aiq_ctx, true);
      LOG_INFO("open ldch ret is %d\n", ret);
      if (ldch_level >= 0)
        ret = ldch_level_set_no_mutex(ldch_level);
    }
    gc_dc_mode = DC_LDCH;
    break;
  }
  case DC_FEC: {
    if (gc_dc_mode != DC_FEC) {
      reset_flag = 1;
    } else {
      if (fec_level > 0)
        fec_level_set_no_mutex(fec_level);
    }
    if (gc_dc_mode == DC_LDCH) {
      ret = rk_aiq_uapi_setLdchEn(db_aiq_ctx, false);
      LOG_INFO("close ldch ret is %d\n", ret);
    }
    LOG_DEBUG("open fec\n");
    gc_dc_mode = DC_FEC;
    break;
  }
  case DC_CLOSE: {
    if (gc_dc_mode == DC_LDCH) {
      ret = rk_aiq_uapi_setLdchEn(db_aiq_ctx, false);
      LOG_INFO("close ldch ret is %d\n", ret);
    }
    if (gc_dc_mode == DC_FEC) {
      reset_flag = 1;
      LOG_INFO("close fec\n");
    }
    gc_dc_mode = DC_CLOSE;
    break;
  }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  if (reset_flag) {
    reset_flow();
  }
  return ret;
}

int dehaze_strength_set_no_mutex(int level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  if (level < 0)
    return ret;
  level = level < 1 ? 1 : level;
  level = level > 10 ? 10 : level;
  ret = rk_aiq_uapi_setMDhzStrth(db_aiq_ctx, true, level);
  LOG_INFO("set dehaze level %d, ret is %d\n", level, ret);
  return ret;
}

int dehaze_strength_set(int level) {
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = dehaze_strength_set_no_mutex(level);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int dehaze_para_set(work_mode_2_t mode, int level) {
  int ret = 0;
  LOG_DEBUG("dehaze mode is %d, dehaze level is %d \n", mode, level);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  if (WM2_INVALID_MODE == gc_dehaze_mode && WM2_INVALID_MODE != mode) {
    gc_dehaze_mode = mode;
  } else if (gc_dehaze_mode != mode) {
    gc_dehaze_mode = mode;
    reset_flow();
    return ret;
  }
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (mode) {
  case WM2_CLOSE_MODE: {
    ret = rk_aiq_uapi_disableDhz(db_aiq_ctx);
    break;
  }
  case WM2_OPEN_MODE: {
    ret = rk_aiq_uapi_enableDhz(db_aiq_ctx);
    ret = rk_aiq_uapi_setDhzMode(db_aiq_ctx, OP_MANUAL);
    ret = dehaze_strength_set_no_mutex(level);
    break;
  }
  case WM2_AUTO_MODE: {
    ret = rk_aiq_uapi_enableDhz(db_aiq_ctx);
    ret = rk_aiq_uapi_setDhzMode(db_aiq_ctx, OP_AUTO);
    break;
  }
  case WM2_INVALID_MODE: {
    LOG_WARN("set invalid dehaze mode\n");
    ret = -1;
    break;
  }
  default: {
    if (gc_dehaze_mode == WM2_OPEN_MODE)
      ret = dehaze_strength_set_no_mutex(level);
  }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}
int exposure_weight_str2array(char *weight,int32_t* g_weight){
    int ret = 0;
    gchar **arr;
    gint i;
    if(weight == NULL){
      return -1;
    }
    LOG_INFO("%s\n", weight);
    if(strstr(weight,",") == NULL){
      return -1;
    }
    arr = g_strsplit(weight, ",", 0);
    for (i = 0; arr[i] != NULL; i++){
	g_weight[i] = atoi(arr[i]);
    }
    return ret;
}
float exposure_time_str2float(char *time) {
  float numerator, denominator, rst;
  if (strcmp(time, "1")) {
    sscanf(time, "%f/%f", &numerator, &denominator);
    rst = numerator / denominator;
  } else {
    sscanf(time, "%f", &rst);
  }
  return rst;
}

int exposure_time_set(char *time) {
  LOG_INFO("time is %s\n", time);
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  paRange_t range;
  range.min = 1e-5; // TODO: obtained from capability
  float numerator, denominator;
  if (strcmp(time, "1")) {
    sscanf(time, "%f/%f", &numerator, &denominator);
    range.max = numerator / denominator;
  } else {
    sscanf(time, "%f", &range.max);
  }
  LOG_INFO("min is %f, max is %f\n", range.min, range.max);
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = rk_aiq_uapi_setExpTimeRange(db_aiq_ctx, &range);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int exposure_gain_set(int gain) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  paRange_t range;
  range.min = 1; // TODO: obtained from capability
  range.max = 1;
  if (gain)
    range.max = (float)gain;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  ret = rk_aiq_uapi_setExpGainRange(db_aiq_ctx, &range);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_DEBUG("set exposure min is %f, max is %f, ret is %d\n", range.min,
            range.max, ret);
  return ret;
}

int auto_exposure_set() {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  Uapi_ExpSwAttr_t stExpSwAttr;
  int ret = -1;

  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
  ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("Set auto exposure, ret is %d\n", ret);
  return ret;
}

int exposure_info_get(Uapi_ExpQueryInfo_t *stExpInfo, rk_aiq_wb_cct_t *stCCT) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = 0;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  if (stExpInfo)
    ret = rk_aiq_user_api_ae_queryExpResInfo(db_aiq_ctx, stExpInfo);
  if (stCCT)
    ret = rk_aiq_user_api_awb_GetCCT(db_aiq_ctx, stCCT);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int manual_exposure_auto_gain_set_char(char *time) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  Uapi_ExpSwAttr_t stExpSwAttr;

  float expTime = exposure_time_str2float(time);
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
  stExpSwAttr.stManual.stLinMe.ManualGainEn = false;
  stExpSwAttr.stManual.stLinMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stLinMe.TimeValue = expTime;

  stExpSwAttr.stManual.stHdrMe.ManualGainEn = false;
  stExpSwAttr.stManual.stHdrMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = expTime;
  int ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO(
      "set manual exposure and auto gain, exposure time is %f, ret is %d\n",
      expTime, ret);
  return ret;
}

int manual_exposure_auto_gain_set_float(float expTime) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  Uapi_ExpSwAttr_t stExpSwAttr;

  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  for (size_t i = 0; i < sizeof(exposure_uvc_time); i++)
  {
    if (expTime == exposure_uvc_time[i])
    {
      expTime = exposure_isp_time[i];
    }
  }

  stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
  stExpSwAttr.stManual.stLinMe.ManualGainEn = false;
  stExpSwAttr.stManual.stLinMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stLinMe.TimeValue = expTime;

  stExpSwAttr.stManual.stHdrMe.ManualGainEn = false;
  stExpSwAttr.stManual.stHdrMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = expTime;
  int ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO(
      "set manual exposure and auto gain, exposure time is %f, ret is %d\n",
      expTime, ret);
  return ret;
}

int manual_exposure_manual_gain_set_char(char *time, int gain) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  Uapi_ExpSwAttr_t stExpSwAttr;
  float expTime = exposure_time_str2float(time);
  // gain[1~100]; if (int)(gain *2.55) + 1.0 then gain[0~100] ->
  // GainValue[1~256]
  float gain_set = (gain * 1.0f);
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
  stExpSwAttr.stManual.stLinMe.ManualGainEn = true;
  stExpSwAttr.stManual.stLinMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stLinMe.TimeValue = expTime;
  stExpSwAttr.stManual.stLinMe.GainValue = gain_set;

  stExpSwAttr.stManual.stHdrMe.ManualGainEn = true;
  stExpSwAttr.stManual.stHdrMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = expTime;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[0] = gain_set;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[1] = gain_set;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[2] = gain_set;
  int ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("expTime is %f, gain is %f, ret is %d\n", expTime, gain_set, ret);
  return ret;
}

int manual_exposure_manual_gain_set_float(float expTime, int gain) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  Uapi_ExpSwAttr_t stExpSwAttr;
  // gain[1~100]; if (int)(gain *2.55) + 1.0 then gain[0~100] ->
  // GainValue[1~256]
  float gain_set = (gain * 1.0f);
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
  stExpSwAttr.stManual.stLinMe.ManualGainEn = true;
  stExpSwAttr.stManual.stLinMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stLinMe.TimeValue = expTime;
  stExpSwAttr.stManual.stLinMe.GainValue = gain_set;

  stExpSwAttr.stManual.stHdrMe.ManualGainEn = true;
  stExpSwAttr.stManual.stHdrMe.ManualTimeEn = true;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = expTime;
  stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = expTime;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[0] = gain_set;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[1] = gain_set;
  stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[2] = gain_set;
  int ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  LOG_INFO("expTime is %f, gain is %f, ret is %d\n", expTime, gain_set, ret);
  return ret;
}

int manual_exposure_grid_weight_set(int32_t* weight,int evbias) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  LOG_INFO(" xy is %d,%d . wh is %d,%d\n",weight[0],weight[1],weight[2],weight[3] );
  Uapi_ExpSwAttr_t stExpSwAttr;
  Uapi_LinExpAttr_t pLinExpAttr;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  rk_aiq_user_api_ae_getExpSwAttr(db_aiq_ctx, &stExpSwAttr);
  rk_aiq_user_api_ae_getLinExpAttr(db_aiq_ctx, &pLinExpAttr);
  pLinExpAttr.Evbias = evbias;
  stExpSwAttr.stAdvanced.enable = true;
  uint8_t DayGridWeights[225]={
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        };
  for(int i = 0; i < 225; i++){
     if(weight[i] != 0 && weight[i] < 225){
	DayGridWeights[weight[i]] = 15;
     }
  }
  if(weight[0] == 0 && weight[1] == 0){
    for(int i = 0; i < 225; i++){
        DayGridWeights[i] = 1;
    }
    pLinExpAttr.Evbias = 0;
    LOG_INFO(" xy is %d,%d . wh is %d,%d\n",weight[0],weight[1],weight[2],weight[3]);
    //stExpSwAttr.stAdvanced.enable = false;
  }
  memcpy(stExpSwAttr.stAdvanced.DayGridWeights,DayGridWeights,sizeof(stExpSwAttr.stAdvanced.DayGridWeights));
  memcpy(stExpSwAttr.stAdvanced.NightGridWeights,DayGridWeights,sizeof(stExpSwAttr.stAdvanced.DayGridWeights));
  int ret = rk_aiq_user_api_ae_setExpSwAttr(db_aiq_ctx, stExpSwAttr);
  ret = rk_aiq_user_api_ae_setLinExpAttr(db_aiq_ctx, pLinExpAttr);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}
static int blc_region_strength_set_no_mutex(int strength) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  if (strength >= 0 && strength <= 100) {
    ret = rk_aiq_uapi_setBLCStrength(db_aiq_ctx, strength);
    LOG_INFO("rk_aiq_uapi_setBLCStrength set %d ret is %d\n", strength, ret);
  } else {
    LOG_WARN("rk_aiq_uapi_setBLCStrength set %d over range\n", strength);
  }
  return ret;
}

int blc_region_para_set(work_mode_1_t mode, int strength) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (mode) {
  case WM1_CLOSE_MODE: {
    ret = rk_aiq_uapi_setBLCMode(db_aiq_ctx, false, AE_MEAS_AREA_AUTO);
    LOG_INFO("rk_aiq_uapi_setBLCMode close ret is %d\n", ret);
    break;
  }
  case WM1_OPEN_MODE: {
    ret = rk_aiq_uapi_setBLCMode(db_aiq_ctx, true, AE_MEAS_AREA_AUTO);
    LOG_INFO("rk_aiq_uapi_setBLCMode open ret is %d\n", ret);
    usleep(30000);
    ret = blc_region_strength_set_no_mutex(strength);
    break;
  }
  default: { LOG_WARN("invalid blc region mode: %d\n", mode); }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int blc_region_strength_set(int strength) {
  int ret = blc_region_para_set(WM1_OPEN_MODE, strength);
  // pthread_mutex_lock(&db_aiq_ctx_mutex);
  // int ret = blc_region_strength_set_no_mutex(strength);
  // pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

static int blc_hlc_level_set_no_mutex(int hlc_level, int dark_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = 0;
  if (hlc_level >= 0) {
    ret = rk_aiq_uapi_setHLCStrength(db_aiq_ctx, hlc_level); // level[1, 100]
    LOG_INFO("rk_aiq_uapi_setHLCStrength ret is %d\n", ret);
  }
  if (dark_level >= 0) {
    ret = rk_aiq_uapi_setDarkAreaBoostStrth(
        db_aiq_ctx, (int)(dark_level / 10)); // level[1, 100] -> [0, 10]
    LOG_INFO("rk_aiq_uapi_setDarkAreaBoostStrth ret is %d\n", ret);
  }
  return ret;
}

int blc_hlc_para_set(work_mode_1_t mode, int hlc_level, int dark_level) {
  if (!db_aiq_ctx || !g_stream_on)
    return -1;
  int ret = -1;
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  switch (mode) {
  case WM1_CLOSE_MODE: {
    ret = rk_aiq_uapi_setHLCMode(db_aiq_ctx, false);
    LOG_INFO("rk_aiq_uapi_setHLCMode close ret is %d\n", ret);
    break;
  }
  case WM1_OPEN_MODE: {
    ret = rk_aiq_uapi_setHLCMode(db_aiq_ctx, true);
    LOG_INFO("rk_aiq_uapi_setHLCMode open ret is %d\n", ret);
    blc_hlc_level_set_no_mutex(hlc_level, dark_level);
    break;
  }
  case WM1_INVALID_MODE: {
    LOG_WARN("invalid mode: %d\n", mode);
    break;
  }
  }
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int blc_hlc_level_set(int hlc_level, int dark_level) {
  pthread_mutex_lock(&db_aiq_ctx_mutex);
  int ret = blc_hlc_level_set_no_mutex(hlc_level, dark_level);
  pthread_mutex_unlock(&db_aiq_ctx_mutex);
  return ret;
}

int isp_status_sender_register(ispserver_status_signal_send send_func) {
  if (!send_func)
    return -1;
  g_send_func = send_func;
  LOG_INFO("register success: %p", g_send_func);
  return 0;
}
#endif